foreman_openscap 4.3.0 → 4.3.1

data/webpack/routes/OvalPolicies/OvalPoliciesShow/CvesTable.js

@@ -0,0 +1,63 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { translate as __ } from 'foremanReact/common/I18n';
+
+import { linkCell } from '../../../helpers/tableHelper';
+import { hostsPath } from '../../../helpers/pathsHelper';
+import { decodeId } from '../../../helpers/globalIdHelper';
+import { addSearch } from '../../../helpers/pageParamsHelper';
+
+import withLoading from '../../../components/withLoading';
+import IndexTable from '../../../components/IndexTable';
+
+const CvesTable = props => {
+  const columns = [
+    { title: __('Ref Id') },
+    { title: __('Has Errata?') },
+    { title: __('Hosts Count') },
+  ];
+
+  const cveRefId = cve => (
+    <a href={cve.refUrl} rel="noopener noreferrer" target="_blank">
+      {cve.refId}
+    </a>
+  );
+
+  const hostCount = cve =>
+    linkCell(
+      addSearch(hostsPath, { search: `cve_id = ${decodeId(cve)}` }),
+      cve.hosts.nodes.length
+    );
+
+  const rows = props.cves.map(cve => ({
+    cells: [
+      { title: cveRefId(cve) },
+      { title: cve.hasErrata ? __('Yes') : __('No') },
+      { title: hostCount(cve) },
+    ],
+    cve,
+  }));
+
+  const actions = [];
+
+  return (
+    <IndexTable
+      columns={columns}
+      rows={rows}
+      actions={actions}
+      pagination={props.pagination}
+      totalCount={props.totalCount}
+      history={props.history}
+      ariaTableLabel={__('Table of CVEs for OVAL policy')}
+    />
+  );
+};
+
+CvesTable.propTypes = {
+  cves: PropTypes.array.isRequired,
+  pagination: PropTypes.object.isRequired,
+  totalCount: PropTypes.number.isRequired,
+  history: PropTypes.object.isRequired,
+};
+
+export default withLoading(CvesTable);

data/webpack/routes/OvalPolicies/OvalPoliciesShow/OvalPoliciesShow.js

@@ -0,0 +1,79 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { Link } from 'react-router-dom';
+import { Helmet } from 'react-helmet';
+import { translate as __ } from 'foremanReact/common/I18n';
+import {
+  Button,
+  Grid,
+  GridItem,
+  TextContent,
+  Text,
+  TextVariants,
+  Tabs,
+  Tab,
+  TabTitleText,
+} from '@patternfly/react-core';
+import '@patternfly/patternfly/patternfly-addons.scss';
+
+import withLoading from '../../../components/withLoading';
+
+import CvesTab from './CvesTab';
+
+import { policySchedule, newJobFormPath } from './OvalPoliciesShowHelper';
+import { resolvePath } from '../../../helpers/pathsHelper';
+
+const OvalPoliciesShow = props => {
+  const { policy, match, history } = props;
+  const activeTab = match.params.tab ? match.params.tab : 'details';
+
+  const handleTabSelect = (event, value) => {
+    history.push(
+      resolvePath(match.path, { ':id': match.params.id, ':tab?': value })
+    );
+  };
+
+  return (
+    <React.Fragment>
+      <Helmet>
+        <title>{`${policy.name} | OVAL Policy`}</title>
+      </Helmet>
+      <Grid className="scap-page-grid">
+        <GridItem span={10}>
+          <Text component={TextVariants.h1}>{policy.name}</Text>
+        </GridItem>
+        <GridItem span={2}>
+          <Link to={newJobFormPath(policy, match.params.id)}>
+            <Button variant="secondary">{__('Scan All Hostgroups')}</Button>
+          </Link>
+        </GridItem>
+        <GridItem span={12}>
+          <Tabs mountOnEnter activeKey={activeTab} onSelect={handleTabSelect}>
+            <Tab
+              eventKey="details"
+              title={<TabTitleText>Details</TabTitleText>}
+            >
+              <TextContent className="pf-u-pt-md">
+                <Text component={TextVariants.h3}>Period</Text>
+                <Text component={TextVariants.p}>{policySchedule(policy)}</Text>
+                <Text component={TextVariants.h3}>Description</Text>
+                <Text component={TextVariants.p}>{policy.description}</Text>
+              </TextContent>
+            </Tab>
+            <Tab eventKey="cves" title={<TabTitleText>CVEs</TabTitleText>}>
+              <CvesTab {...props} />
+            </Tab>
+          </Tabs>
+        </GridItem>
+      </Grid>
+    </React.Fragment>
+  );
+};
+
+OvalPoliciesShow.propTypes = {
+  match: PropTypes.object.isRequired,
+  history: PropTypes.object.isRequired,
+  policy: PropTypes.object.isRequired,
+};
+
+export default withLoading(OvalPoliciesShow);

data/webpack/routes/OvalPolicies/OvalPoliciesShow/OvalPoliciesShowHelper.js

@@ -0,0 +1,39 @@
+import { decodeId } from '../../../helpers/globalIdHelper';
+import { addSearch } from '../../../helpers/pageParamsHelper';
+import { newJobPath } from '../../../helpers/pathsHelper';
+
+export const policySchedule = policy => {
+  switch (policy.period) {
+    case 'weekly':
+      return `Weekly, on ${policy.weekday}`;
+    case 'monthly':
+      return `Monthly, day of month: ${policy.dayOfMonth}`;
+    case 'custom':
+      return `Custom cron: ${policy.cronLine}`;
+    default:
+      return 'Unknown schedule';
+  }
+};
+
+const targetingScopedSearchQuery = policy => {
+  const hgIds = policy.hostgroups.nodes.reduce((memo, hg) => {
+    const ids = [decodeId(hg)].concat(hg.descendants.nodes.map(decodeId));
+    return ids.reduce(
+      (acc, id) => (acc.includes(id) ? acc : [...acc, id]),
+      memo
+    );
+  }, []);
+
+  if (hgIds.length === 0) {
+    return '';
+  }
+
+  return `hostgroup_id ^ (${hgIds.join(' ')})`;
+};
+
+export const newJobFormPath = (policy, policyId) =>
+  addSearch(newJobPath, {
+    feature: 'foreman_openscap_run_oval_scans',
+    host_ids: targetingScopedSearchQuery(policy),
+    'inputs[oval_policies]': policyId,
+  });

data/webpack/routes/OvalPolicies/OvalPoliciesShow/__tests__/OvalPoliciesShow.fixtures.js

@@ -0,0 +1,78 @@
+import { mockFactory } from '../../../../testHelper';
+import ovalPolicyQuery from '../../../../graphql/queries/ovalPolicy.gql';
+import cvesQuery from '../../../../graphql/queries/cves.gql';
+
+const policyDetailMockFactory = mockFactory('ovalPolicy', ovalPolicyQuery);
+const cvesMockFactory = mockFactory('cves', cvesQuery);
+
+const ovalPolicy = {
+  id: 'MDE6Rm9yZW1hbk9wZW5zY2FwOjpPdmFsUG9saWN5LTM=',
+  name: 'Third policy',
+  period: 'weekly',
+  cronLine: null,
+  weekday: 'tuesday',
+  dayOfMonth: null,
+  description: 'A very strict policy',
+  hostgroups: {
+    nodes: [
+      {
+        id: 'MDE6SG9zdGdyb3VwLTQ=',
+        name: 'oval hg',
+        descendants: {
+          nodes: [
+            { id: 'MDE6SG9zdGdyb3VwLTEw' },
+            { id: 'MDE6SG9zdGdyb3VwLTEy' },
+            { id: 'MDE6SG9zdGdyb3VwLTEx' },
+          ],
+        },
+      },
+    ],
+  },
+};
+
+const cvesResult = {
+  totalCount: 1,
+  nodes: [
+    {
+      id: 'MDE6Rm9yZW1hbk9wZW5zY2FwOjpDdmUtMjY3',
+      refId: 'CVE-2020-14365',
+      refUrl: 'https://access.redhat.com/security/cve/CVE-2020-14365',
+      definitionId: 'oval:com.redhat.rhsa:def:20203601',
+      hasErrata: true,
+      hosts: {
+        nodes: [
+          {
+            id: 'MDE6SG9zdC0z',
+            name: 'centos-random.example.com',
+          },
+        ],
+      },
+    },
+  ],
+};
+
+export const ovalPolicyId = 3;
+
+export const pushMock = jest.fn();
+
+export const historyMock = {
+  location: {
+    search: '',
+  },
+  push: pushMock,
+};
+
+export const historyWithSearch = {
+  location: {
+    search: '?page=1&perPage=5',
+  },
+};
+
+export const policyDetailMock = policyDetailMockFactory(
+  { id: ovalPolicy.id },
+  ovalPolicy
+);
+export const policyCvesMock = cvesMockFactory(
+  { search: `oval_policy_id = ${ovalPolicyId}`, first: 5, last: 5 },
+  cvesResult
+);

data/webpack/routes/OvalPolicies/OvalPoliciesShow/__tests__/OvalPoliciesShow.test.js

@@ -0,0 +1,112 @@
+import React from 'react';
+import { Router } from 'react-router-dom';
+import { render, screen, waitFor } from '@testing-library/react';
+import { within } from '@testing-library/dom';
+import '@testing-library/jest-dom';
+import userEvent from '@testing-library/user-event';
+import { createMemoryHistory } from 'history';
+
+import OvalPoliciesShow from '../index';
+import {
+  ovalPoliciesShowPath,
+  resolvePath,
+} from '../../../../helpers/pathsHelper';
+
+import { withMockedProvider, tick, withRouter } from '../../../../testHelper';
+import {
+  policyDetailMock,
+  historyMock,
+  historyWithSearch,
+  pushMock,
+  policyCvesMock,
+  ovalPolicyId,
+} from './OvalPoliciesShow.fixtures';
+
+const TestComponent = withRouter(withMockedProvider(OvalPoliciesShow));
+
+describe('OvalPoliciesShow', () => {
+  it('should load details by default and handle tab change', async () => {
+    const { container } = render(
+      <TestComponent
+        history={historyMock}
+        match={{ params: { id: ovalPolicyId }, path: ovalPoliciesShowPath }}
+        mocks={policyDetailMock}
+      />
+    );
+    expect(screen.getByText('Loading')).toBeInTheDocument();
+    await waitFor(tick);
+    expect(screen.queryByText('Loading')).not.toBeInTheDocument();
+    expect(screen.getByText('Third policy')).toBeInTheDocument();
+    expect(screen.getByText('Weekly, on tuesday')).toBeInTheDocument();
+    expect(screen.getByText('A very strict policy')).toBeInTheDocument();
+    const activeTabHeader = container.querySelector(
+      '.pf-c-tabs__item.pf-m-current'
+    );
+    expect(within(activeTabHeader).getByText('Details')).toBeInTheDocument();
+    userEvent.click(screen.getByRole('button', { name: 'CVEs' }));
+    expect(pushMock).toHaveBeenCalledWith(
+      resolvePath(ovalPoliciesShowPath, {
+        ':id': ovalPolicyId,
+        ':tab?': 'cves',
+      })
+    );
+  });
+  it('should load details tab when specified in URL', async () => {
+    render(
+      <TestComponent
+        history={historyMock}
+        match={{
+          params: { id: ovalPolicyId, tab: 'details' },
+          path: ovalPoliciesShowPath,
+        }}
+        mocks={policyDetailMock}
+      />
+    );
+    expect(screen.getByText('Loading')).toBeInTheDocument();
+    await waitFor(tick);
+    expect(screen.queryByText('Loading')).not.toBeInTheDocument();
+    expect(screen.getByText('Weekly, on tuesday')).toBeInTheDocument();
+  });
+  it('should load CVEs tab when specified in URL', async () => {
+    const mocks = policyDetailMock.concat(policyCvesMock);
+    render(
+      <TestComponent
+        history={historyWithSearch}
+        match={{
+          params: { id: ovalPolicyId, tab: 'cves' },
+          path: ovalPoliciesShowPath,
+        }}
+        mocks={mocks}
+      />
+    );
+    expect(screen.getByText('Loading')).toBeInTheDocument();
+    await waitFor(tick);
+    await waitFor(tick);
+    expect(screen.queryByText('Loading')).not.toBeInTheDocument();
+    expect(screen.getByText('CVE-2020-14365')).toBeInTheDocument();
+  });
+  it('should have button for scanning all hostgroups', async () => {
+    const btnText = 'Scan All Hostgroups';
+
+    const WithProvider = withMockedProvider(OvalPoliciesShow);
+    const history = createMemoryHistory();
+    history.push = jest.fn();
+
+    render(
+      <Router history={history}>
+        <WithProvider
+          history={history}
+          match={{ params: { id: ovalPolicyId }, path: ovalPoliciesShowPath }}
+          mocks={policyDetailMock}
+        />
+      </Router>
+    );
+    await waitFor(tick);
+    expect(screen.queryByText('Loading')).not.toBeInTheDocument();
+    expect(screen.getByText(btnText)).toBeInTheDocument();
+    userEvent.click(screen.getByRole('button', { name: btnText }));
+    expect(history.push).toHaveBeenCalledWith(
+      '/job_invocations/new?feature=foreman_openscap_run_oval_scans&host_ids=hostgroup_id+%5E+%284+10+12+11%29&inputs%5Boval_policies%5D=3'
+    );
+  });
+});

data/webpack/routes/OvalPolicies/OvalPoliciesShow/index.js

@@ -0,0 +1,35 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { useQuery } from '@apollo/client';
+
+import { translate as __ } from 'foremanReact/common/I18n';
+
+import OvalPoliciesShow from './OvalPoliciesShow';
+import { encodeId } from '../../../helpers/globalIdHelper';
+
+import ovalPolicy from '../../../graphql/queries/ovalPolicy.gql';
+
+const WrappedOvalPoliciesShow = props => {
+  const id = encodeId('ForemanOpenscap::OvalPolicy', props.match.params.id);
+
+  const useFetchFn = componentProps =>
+    useQuery(ovalPolicy, { variables: { id } });
+
+  const renameData = data => ({ policy: data.ovalPolicy });
+
+  return (
+    <OvalPoliciesShow
+      {...props}
+      fetchFn={useFetchFn}
+      renameData={renameData}
+      resultPath="ovalPolicy"
+      emptyStateTitle={__('No OVAL Policy found')}
+    />
+  );
+};
+
+WrappedOvalPoliciesShow.propTypes = {
+  match: PropTypes.object.isRequired,
+};
+
+export default WrappedOvalPoliciesShow;

data/webpack/routes/routes.js

@@ -0,0 +1,28 @@
+import React from 'react';
+import OvalContentsIndex from './OvalContents/OvalContentsIndex';
+import OvalPoliciesIndex from './OvalPolicies/OvalPoliciesIndex';
+import OvalPoliciesShow from './OvalPolicies/OvalPoliciesShow';
+
+import {
+  ovalContentsPath,
+  ovalPoliciesPath,
+  ovalPoliciesShowPath,
+} from '../helpers/pathsHelper';
+
+export default [
+  {
+    path: ovalContentsPath,
+    render: props => <OvalContentsIndex {...props} />,
+    exact: true,
+  },
+  {
+    path: ovalPoliciesPath,
+    render: props => <OvalPoliciesIndex {...props} />,
+    exact: true,
+  },
+  {
+    path: ovalPoliciesShowPath,
+    render: props => <OvalPoliciesShow {...props} />,
+    exact: true,
+  },
+];

data/webpack/testHelper.js

@@ -0,0 +1,64 @@
+import React from 'react';
+import { MockedProvider } from '@apollo/react-testing';
+import { MemoryRouter } from 'react-router-dom';
+import { getForemanContext } from 'foremanReact/Root/Context/ForemanContext';
+
+export const withRouter = Component => props => (
+  <MemoryRouter>
+    <Component {...props} />
+  </MemoryRouter>
+);
+
+export const withMockedProvider = Component => props => {
+  const ForemanContext = getForemanContext(ctx);
+  // eslint-disable-next-line react/prop-types
+  const { mocks, ...rest } = props;
+
+  const ctx = {
+    metadata: {
+      UISettings: {
+        perPage: 20,
+      },
+    },
+  };
+
+  return (
+    <ForemanContext.Provider value={ctx}>
+      <MockedProvider mocks={mocks} addTypename={false}>
+        <Component {...rest} />
+      </MockedProvider>
+    </ForemanContext.Provider>
+  );
+};
+
+// use to resolve async mock requests for apollo MockedProvider
+export const tick = () => new Promise(resolve => setTimeout(resolve, 0));
+
+export const historyMock = {
+  location: {
+    search: '',
+  },
+};
+
+export const mockFactory = (resultName, query) => (
+  variables,
+  modelResults,
+  errors = []
+) => {
+  const mock = {
+    request: {
+      query,
+      variables,
+    },
+    result: {
+      data: {
+        [resultName]: modelResults,
+      },
+    },
+  };
+
+  if (errors.length !== 0) {
+    mock.result.errors = errors;
+  }
+  return [mock];
+};