foreman_openscap 12.1.2 → 13.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7d8a562f0b445928773ee7d56fb55865ed3209a6d91b87c1ee8f39d414f1f772
-  data.tar.gz: 3b30bb1362e2ce2cc5105cd54f84cc643f809026c207f17b9118ea5357a73f4b
+  metadata.gz: 31e3721d3419a9695bb06d27b4dc1f79daf7aa825fe091afdd5ce3ab84fec6d5
+  data.tar.gz: '09f41b5c13f636a9227ace3b2e2b7c27f5341d22400d98afdcddc597c5650af6'
 SHA512:
-  metadata.gz: 8dab6bff24fe0a6bf0a757f097f11dbcf598f55fa258bb973f018365ef42c574d579734caa9ec353ced159bb085adf77d49a3a45f1e5bfcfb19e7f219b5d7e00
-  data.tar.gz: 3733b383bd767e0e606f2625904eae09899ec39aea038a6bae0ba4a45b127b71a9e16f25a571f107039db67d3e7cb67402cdb7156de9f3cec9a7dfb0eec26d6c
+  metadata.gz: 508fba001dca06e61ae108a10ca54193eec9ab3ba4f26b310481713a852aef69d09c720fdd44ea8ecf89a741a906c30b415640497894f4e0da92b14f0bb5de15
+  data.tar.gz: ffcc23a0d7bd9ecf624ee81f6e46eadd02fc1bf9111e8bd15648590e9f435a7872e6791f2197d024f680628bdf9de5f6e602c5b13f156984130b2865ad381d34

data/app/assets/stylesheets/foreman_openscap/scap_breakdown_chart.css

@@ -1,3 +1,18 @@
+.compliance-host-policy-row {
+  display: flex;
+  flex-wrap: wrap;
+
+  > [class*='col-'] {
+    display: flex;
+    flex-direction: column;
+  }
+
+  .stats-well {
+    flex: 1 1 auto;
+    width: 100%;
+  }
+}
+
 .scap-breakdown-chart {
   margin: 25px auto 12px;
   width: 240px;

data/app/models/foreman_openscap/compliance_status.rb

@@ -43,11 +43,11 @@ module ForemanOpenscap
     def relevant?(options = {})
       # May fail host status during migration
       return false unless ForemanOpenscap::Asset.table_exists?
-      host.policies.present?
+      host.combined_policies.present?
     end
 
     def to_status(options = {})
-      latest_reports = host.policies.map { |p| host.last_report_for_policy p }.flatten
+      latest_reports = host.combined_policies.flat_map { |p| host.last_report_for_policy p }
       return INCOMPLIANT if latest_reports.any?(&:failed?)
       return INCONCLUSIVE if latest_reports.any?(&:othered?)
       COMPLIANT

data/app/views/compliance_hosts/show.html.erb

@@ -1,5 +1,7 @@
-<% javascript 'foreman_openscap/scap_hosts_show' %>
 <% stylesheet 'foreman_openscap/scap_breakdown_chart' %>
+<% content_for(:javascripts) do %>
+  <%= webpacked_plugins_js_for :foreman_openscap %>
+<% end %>
 
 <%= breadcrumbs(:resource_url => api_hosts_path,
                 :resource_filter => "is_compliance_host = true",
@@ -8,7 +10,7 @@
 <% title n_("%s compliance report by policy", "%s compliance reports by policy" , @host.combined_policies.length) % @host.to_label %>
 <% @host.combined_policies.each do |policy| %>
   <h2 class="center-block"><%= _('Policy %s') % policy %></h2>
-  <div class="row">
+  <div class="row compliance-host-policy-row">
     <% data = ForemanOpenscap::HostReportDashboard::Data.new(policy, @host) %>
     <% if data.has_data? %>
     <div class="col-md-4">
@@ -26,7 +28,7 @@
     <div class="col-md-8">
       <div class="stats-well">
         <h4 class="ca"><%= _("%s reports over time") % policy %></h4>
-        <%= react_component('LineChart', host_arf_reports_chart_data(policy.id)) %>
+        <%= react_component('OpenscapLineChart', host_arf_reports_chart_data(policy.id)) %>
       </div>
     </div>
     <% else %>

data/lib/foreman_openscap/engine.rb

@@ -40,7 +40,7 @@ module ForemanOpenscap
     initializer 'foreman_openscap.register_plugin', :before => :finisher_hook do |app|
       app.reloader.to_prepare do
         Foreman::Plugin.register :foreman_openscap do
-          requires_foreman '>= 3.17'
+          requires_foreman '>= 5.0'
           register_gettext
 
           apipie_documented_controllers ["#{ForemanOpenscap::Engine.root}/app/controllers/api/v2/compliance/*.rb"]

data/lib/foreman_openscap/version.rb

@@ -1,3 +1,3 @@
 module ForemanOpenscap
-  VERSION = "12.1.2".freeze
+  VERSION = "13.0.1".freeze
 end

data/test/unit/compliance_status_test.rb

@@ -69,4 +69,54 @@ class ComplianceStatusTest < ActiveSupport::TestCase
     status.host = host
     assert_equal 0, status.to_status
   end
+
+  test 'relevant? should be true for host policies' do
+    status = ForemanOpenscap::ComplianceStatus.new
+    host = FactoryBot.create(:compliance_host, :policies => [@policy_a])
+
+    status.host = host
+
+    assert status.relevant?
+  end
+
+  test 'relevant? should be true for hostgroup policies and to_status should use them' do
+    status = ForemanOpenscap::ComplianceStatus.new
+    host = FactoryBot.create(:host, :with_hostgroup)
+    othered_status = { :passed => 0, :failed => 0, :othered => 1 }.with_indifferent_access
+
+    assert_empty host.policies
+    @policy_a.hostgroup_ids = [host.hostgroup.id]
+    assert @policy_a.save
+
+    host.reload
+    assert_includes host.combined_policies, @policy_a
+
+    report = FactoryBot.create(:arf_report, :host_id => host.id, :status => othered_status)
+    FactoryBot.create(:policy_arf_report, :policy_id => @policy_a.id, :arf_report_id => report.id)
+
+    status.host = host
+
+    assert status.relevant?
+    assert_equal ForemanOpenscap::ComplianceStatus::INCONCLUSIVE, status.to_status
+  end
+
+  test 'relevant? should be true for inherited parent hostgroup policies' do
+    status = ForemanOpenscap::ComplianceStatus.new
+    host = FactoryBot.create(:host, :with_hostgroup)
+    hostgroup = host.hostgroup
+
+    hostgroup.parent = FactoryBot.create(:hostgroup)
+    hostgroup.save!
+
+    assert_empty host.policies
+    @policy_a.hostgroup_ids = [hostgroup.parent.id]
+    assert @policy_a.save
+
+    host.reload
+    assert_includes host.combined_policies, @policy_a
+
+    status.host = host
+
+    assert status.relevant?
+  end
 end

data/webpack/components/LineChart/LineChart.fixtures.js

@@ -0,0 +1,28 @@
+export const data = [
+  ['red', [5, 7, 9], '#AA4643'],
+  ['green', [2, 4, 6], '#89A54E'],
+];
+
+const dates = [1557014400000, 1559779200000, 1562457600000];
+
+export const timeseriesData = [
+  ['Passed', [5, 7, 9], '#3f9c35'],
+  ['Failed', [2, 4, 6], '#c9190b'],
+  ['Othered', [1, 0, 2], '#f0ab00'],
+  ['dates', dates, null],
+];
+
+export const emptyTimeseriesData = [
+  ['Passed', [0, 0, 0], '#3f9c35'],
+  ['Failed', [0, 0, 0], '#c9190b'],
+  ['Othered', [0, 0, 0], '#f0ab00'],
+  ['dates', dates, null],
+];
+
+/** Spread-column format used by some Foreman chart fixtures. */
+export const spreadTimeseriesData = [
+  ['Passed', 5, 7, 9, '#3f9c35'],
+  ['Failed', 2, 4, 6, '#c9190b'],
+  ['Othered', 1, 0, 2, '#f0ab00'],
+  ['dates', ...dates, null],
+];

data/webpack/components/LineChart/LineChart.scss

@@ -0,0 +1,7 @@
+.line-chart-container {
+  width: 100%;
+  height: 350px;
+  min-width: 200px;
+  min-height: 200px;
+  overflow: visible;
+}

data/webpack/components/LineChart/LineChart.test.js

@@ -0,0 +1,266 @@
+import React from 'react';
+import { render, screen, fireEvent } from '@testing-library/react';
+import '@testing-library/jest-dom';
+
+import {
+  formatAxisTick,
+  formatTooltipTitle,
+  getXAxisTickValues,
+} from 'foremanReact/components/common/charts/helpers/LegendHelpers';
+
+import LineChart from './index';
+import {
+  data,
+  timeseriesData,
+  emptyTimeseriesData,
+  spreadTimeseriesData,
+} from './LineChart.fixtures';
+import {
+  processChartData,
+  hasChartData,
+  sanitizeChartDimension,
+  clampChartPadding,
+  getTimeseriesXDomain,
+  buildLineChartLegendData,
+  formatTooltipValue,
+} from './LineChartHelpers';
+
+jest.unmock('./');
+
+const chartSize = { width: 800, height: 350 };
+
+describe('hasChartData', () => {
+  it('returns false when all series values are zero', () => {
+    expect(hasChartData(emptyTimeseriesData, 'dates')).toBe(false);
+  });
+
+  it('returns true when any series has a non-zero value', () => {
+    expect(hasChartData(timeseriesData, 'dates')).toBe(true);
+  });
+});
+
+describe('chart layout helpers', () => {
+  it('sanitizes invalid chart dimensions', () => {
+    expect(sanitizeChartDimension(Infinity, 350)).toBe(350);
+    expect(sanitizeChartDimension(NaN, 800)).toBe(800);
+    expect(sanitizeChartDimension(500, 800)).toBe(500);
+  });
+
+  it('clamps padding when it exceeds chart size', () => {
+    const padding = clampChartPadding(
+      { top: 50, bottom: 125, left: 300, right: 170 },
+      400,
+      350
+    );
+
+    expect(padding.left + padding.right).toBeLessThan(400);
+    expect(padding.top + padding.bottom).toBeLessThan(350);
+  });
+
+  it('expands degenerate timeseries x domains', () => {
+    const singlePointData = [
+      ['Passed', [5], '#3f9c35'],
+      ['dates', [1557014400000], null],
+    ];
+    const chartData = processChartData(singlePointData, 'dates', 'timeseries');
+    const domain = getTimeseriesXDomain(chartData);
+
+    expect(domain).toHaveLength(2);
+    expect(domain[0].getTime()).toBeLessThan(domain[1].getTime());
+  });
+});
+
+describe('buildLineChartLegendData', () => {
+  it('uses backend series colors for visible legend symbols', () => {
+    const chartData = processChartData(timeseriesData, 'dates', 'timeseries');
+    const legendData = buildLineChartLegendData(chartData, new Set());
+
+    expect(legendData).toEqual([
+      {
+        childName: 'Passed',
+        name: 'Passed',
+        symbol: { type: 'square', fill: '#3f9c35' },
+      },
+      {
+        childName: 'Failed',
+        name: 'Failed',
+        symbol: { type: 'square', fill: '#c9190b' },
+      },
+      {
+        childName: 'Othered',
+        name: 'Othered',
+        symbol: { type: 'square', fill: '#f0ab00' },
+      },
+    ]);
+  });
+
+  it('uses eyeSlash symbol for hidden series', () => {
+    const chartData = processChartData(timeseriesData, 'dates', 'timeseries');
+    const legendData = buildLineChartLegendData(chartData, new Set(['Failed']));
+
+    expect(legendData[1]).toMatchObject({
+      childName: 'Failed',
+      name: 'Failed',
+      symbol: { type: 'eyeSlash' },
+    });
+    expect(legendData[1].symbol.fill).toBeDefined();
+  });
+});
+
+describe('formatTooltipValue', () => {
+  it('formats rule counts as whole numbers', () => {
+    expect(formatTooltipValue(10)).toBe('10');
+    expect(formatTooltipValue(10.0)).toBe('10');
+    expect(formatTooltipValue(0)).toBe('0');
+  });
+
+  it('rounds non-integer values', () => {
+    expect(formatTooltipValue(6.7)).toBe('7');
+  });
+});
+
+describe('LineChart', () => {
+  it('renders chart with regular data', () => {
+    const { container } = render(
+      <LineChart data={data} config="regular" size={chartSize} />
+    );
+
+    expect(container.querySelector('svg')).toBeInTheDocument();
+  });
+
+  it('renders chart with timeseries data', () => {
+    const { container } = render(
+      <LineChart
+        data={timeseriesData}
+        config="timeseries"
+        xAxisDataLabel="dates"
+        size={chartSize}
+      />
+    );
+
+    expect(container.querySelector('svg')).toBeInTheDocument();
+  });
+
+  it('renders chart with spread-column timeseries data', () => {
+    const { container } = render(
+      <LineChart
+        data={spreadTimeseriesData}
+        config="timeseries"
+        xAxisDataLabel="dates"
+        size={chartSize}
+      />
+    );
+
+    expect(container.querySelector('svg')).toBeInTheDocument();
+  });
+
+  it('renders empty state when no data provided', () => {
+    const { container } = render(<LineChart data={null} />);
+
+    expect(screen.getByText('No data available')).toBeInTheDocument();
+    expect(
+      container.querySelector('.line-chart-container')
+    ).not.toBeInTheDocument();
+  });
+
+  it('renders empty state when all values are zero', () => {
+    const { container } = render(
+      <LineChart
+        data={emptyTimeseriesData}
+        config="timeseries"
+        xAxisDataLabel="dates"
+      />
+    );
+
+    expect(screen.getByText('No data available')).toBeInTheDocument();
+    expect(
+      container.querySelector('.line-chart-container')
+    ).not.toBeInTheDocument();
+  });
+
+  it('displays custom noDataMsg', () => {
+    const customMsg = 'Custom no data message';
+    render(<LineChart data={null} noDataMsg={customMsg} />);
+
+    expect(screen.getByText(customMsg)).toBeInTheDocument();
+  });
+
+  it('renders legend items for each series', () => {
+    const { container } = render(
+      <LineChart
+        data={timeseriesData}
+        config="timeseries"
+        xAxisDataLabel="dates"
+        size={chartSize}
+      />
+    );
+
+    expect(container.textContent).toContain('Passed');
+    expect(container.textContent).toContain('Failed');
+    expect(container.textContent).toContain('Othered');
+  });
+
+  it('legend items are interactive (button role for accessibility)', () => {
+    render(
+      <LineChart
+        data={timeseriesData}
+        config="timeseries"
+        xAxisDataLabel="dates"
+        size={chartSize}
+      />
+    );
+
+    expect(
+      screen.getAllByRole('button', { name: 'Passed' }).length
+    ).toBeGreaterThan(0);
+  });
+
+  it('clicking legend toggles series visibility', () => {
+    const { container } = render(
+      <LineChart
+        data={timeseriesData}
+        config="timeseries"
+        xAxisDataLabel="dates"
+        size={chartSize}
+      />
+    );
+
+    const labels = container.querySelectorAll('.chart-legend-label');
+    expect(labels.length).toBeGreaterThan(0);
+
+    const firstLabel = labels[0];
+    expect(firstLabel).toHaveAttribute('data-hidden', 'false');
+
+    fireEvent.click(firstLabel);
+    expect(firstLabel).toHaveAttribute('data-hidden', 'true');
+
+    fireEvent.click(firstLabel);
+    expect(firstLabel).toHaveAttribute('data-hidden', 'false');
+  });
+
+  it('formats tooltip title for timeseries data points', () => {
+    const chartData = processChartData(timeseriesData, 'dates', 'timeseries');
+    const title = formatTooltipTitle(chartData[0].data[0]);
+
+    expect(title).toMatch(/\d/);
+    expect(title).toContain(',');
+  });
+
+  it('does not show duplicate x-axis labels when multiple data points fall within the same minute', () => {
+    const denseData = [
+      ['Passed', [1, 2, 3], '#3f9c35'],
+      ['Failed', [1, 2, 3], '#c9190b'],
+      ['dates', [1614449768000, 1614449769000, 1614451500000], null],
+    ];
+    const chartData = processChartData(denseData, 'dates', 'timeseries');
+    const tickValues = getXAxisTickValues(chartData, 6);
+
+    expect(tickValues).toBeDefined();
+    expect(tickValues.length).toBeGreaterThan(0);
+
+    const formattedLabels = tickValues.map(t => formatAxisTick(t));
+    const uniqueLabels = [...new Set(formattedLabels)];
+
+    expect(formattedLabels).toHaveLength(uniqueLabels.length);
+  });
+});

data/webpack/components/LineChart/LineChartHelpers.js

@@ -0,0 +1,206 @@
+/** Backend sends [label, values, color]; legacy Foreman charts used spread columns. */
+import { chart_color_black_500 as chartColorBlack500 } from '@patternfly/react-tokens';
+import {
+  MS_PER_SECOND,
+  SECONDS_PER_MINUTE,
+  MINUTES_PER_HOUR,
+  HOURS_PER_HALF_DAY,
+} from 'foremanReact/constants';
+
+const TIMESTAMP_THRESHOLD = 1e12;
+const DEFAULT_TICK_MID = 0.5;
+const MIN_TICK_STEP = 0.1;
+const EXPONENTIAL_THRESHOLD = 1e21;
+const CLAMP_SCALE_FACTOR = 0.9;
+
+const getColumnValues = col => {
+  if (Array.isArray(col[1])) return col[1];
+
+  const values = col.slice(1);
+  const last = values[values.length - 1];
+
+  if (
+    values.length > 1 &&
+    (last == null || (typeof last === 'string' && last.startsWith('#')))
+  ) {
+    return values.slice(0, -1);
+  }
+
+  return values;
+};
+
+const getSeriesColor = col => {
+  if (typeof col[2] === 'string' && col[2].startsWith('#')) {
+    return col[2];
+  }
+
+  const last = col[col.length - 1];
+  if (typeof last === 'string' && last.startsWith('#')) {
+    return last;
+  }
+
+  return undefined;
+};
+
+const toMs = val => {
+  const n = Number(val);
+  return n >= TIMESTAMP_THRESHOLD ? n : n * MS_PER_SECOND;
+};
+
+/** Process raw backend data into chart series for PatternFly line charts. */
+export const processChartData = (data, xAxisDataLabel, config) => {
+  if (!data || data.length === 0) return null;
+
+  if (config === 'timeseries') {
+    const timeColumn = data.find(col => col[0] === xAxisDataLabel);
+    if (!timeColumn) return null;
+
+    const xValues = getColumnValues(timeColumn).map(t => toMs(t));
+
+    const series = data
+      .filter(col => col[0] !== xAxisDataLabel)
+      .map(col => {
+        const values = getColumnValues(col);
+        return {
+          name: col[0],
+          color: getSeriesColor(col),
+          data: values.map((value, index) => ({
+            x: new Date(xValues[index]),
+            y: value ?? 0,
+            name: col[0],
+          })),
+        };
+      });
+
+    return series.length > 0 ? series : null;
+  }
+
+  const series = data.map(col => {
+    const values = getColumnValues(col);
+    return {
+      name: col[0],
+      color: getSeriesColor(col),
+      data: values.map((value, index) => ({
+        x: index + 1,
+        y: value ?? 0,
+        name: col[0],
+      })),
+    };
+  });
+
+  return series.some(s => s.data.length > 0) ? series : null;
+};
+
+export const hasChartData = (data, xAxisDataLabel) => {
+  if (!data || data.length === 0) return false;
+
+  return data
+    .filter(col => col[0] !== xAxisDataLabel)
+    .some(col =>
+      getColumnValues(col).some(value => value !== 0 && value != null)
+    );
+};
+
+export const getYTickValues = (chartData, hiddenSeries = new Set()) => {
+  if (!chartData?.length) return undefined;
+
+  let maxY = 0;
+  chartData
+    .filter(chartSeries => !hiddenSeries.has(chartSeries.name))
+    .forEach(chartSeries => {
+      chartSeries.data.forEach(point => {
+        maxY = Math.max(maxY, point.y ?? 0);
+      });
+    });
+
+  if (maxY <= 0) return [0, DEFAULT_TICK_MID, 1.0];
+
+  const step = Math.max(MIN_TICK_STEP, Math.ceil((maxY / 4) * 10) / 10);
+  return [0, 1, 2, 3, 4, 5].map(i => Math.round(i * step * 10) / 10);
+};
+
+/** Rule counts are whole numbers; avoid decimal formatting in tooltips. */
+export const formatTooltipValue = value => {
+  const num = Number(value);
+  if (!Number.isFinite(num)) return '';
+  if (Math.abs(num) >= EXPONENTIAL_THRESHOLD) {
+    return num.toExponential(1);
+  }
+  return String(Math.round(num));
+};
+
+export const sanitizeChartDimension = (value, fallback) => {
+  const n = Number(value);
+  return Number.isFinite(n) && n > 0 ? n : fallback;
+};
+
+/** Prevent padding from exceeding chart size, which breaks Victory scale/range math. */
+export const clampChartPadding = (padding, width, height) => {
+  let { top = 0, bottom = 0, left = 0, right = 0 } = padding;
+
+  const horizontalTotal = left + right;
+  if (horizontalTotal >= width) {
+    const scale = (width * CLAMP_SCALE_FACTOR) / horizontalTotal;
+    left *= scale;
+    right *= scale;
+  }
+
+  const verticalTotal = top + bottom;
+  if (verticalTotal >= height) {
+    const scale = (height * CLAMP_SCALE_FACTOR) / verticalTotal;
+    top *= scale;
+    bottom *= scale;
+  }
+
+  return { top, bottom, left, right };
+};
+
+/** Expand degenerate time domains so Victory can draw valid line paths. */
+export const getTimeseriesXDomain = chartData => {
+  if (!chartData?.[0]?.data?.length) return undefined;
+
+  const times = chartData[0].data.map(point =>
+    point.x instanceof Date ? point.x.getTime() : new Date(point.x).getTime()
+  );
+  const min = Math.min(...times);
+  const max = Math.max(...times);
+
+  if (min === max) {
+    const offset =
+      HOURS_PER_HALF_DAY *
+      MINUTES_PER_HOUR *
+      SECONDS_PER_MINUTE *
+      MS_PER_SECOND;
+    return [new Date(min - offset), new Date(max + offset)];
+  }
+
+  return undefined;
+};
+
+/** Legend swatches must use backend series colors, not the default PF theme scale. */
+export const buildLineChartLegendData = (chartData, hiddenSeries) =>
+  chartData.map(series => {
+    const hidden = hiddenSeries.has(series.name);
+
+    if (hidden) {
+      return {
+        childName: series.name,
+        name: series.name,
+        symbol: {
+          type: 'eyeSlash',
+          fill: chartColorBlack500.var,
+        },
+      };
+    }
+
+    return {
+      childName: series.name,
+      name: series.name,
+      ...(series.color && {
+        symbol: {
+          type: 'square',
+          fill: series.color,
+        },
+      }),
+    };
+  });