foreman_openscap 4.3.0 → 5.0.0

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

@@ -0,0 +1,98 @@
+import React from 'react';
+import { render, screen, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { within } from '@testing-library/dom';
+import '@testing-library/jest-dom';
+
+import {
+  withMockedProvider,
+  withRouter,
+  tick,
+  historyMock,
+} from '../../../../testHelper';
+
+import {
+  mocks,
+  pushMock,
+  pageParamsMocks,
+  pageParamsHistoryMock,
+  emptyMocks,
+  errorMocks,
+  viewerMocks,
+  unauthorizedMocks,
+} from './OvalPoliciesIndex.fixtures';
+
+import OvalPoliciesIndex from '../OvalPoliciesIndex';
+import { ovalPoliciesPath } from '../../../../helpers/pathsHelper';
+
+const TestComponent = withRouter(withMockedProvider(OvalPoliciesIndex));
+
+describe('OvalPoliciesIndex', () => {
+  it('should load page', async () => {
+    const { container } = render(
+      <TestComponent history={historyMock} mocks={mocks} />
+    );
+    expect(screen.getByText('Loading')).toBeInTheDocument();
+    await waitFor(tick);
+    expect(screen.getByText('first policy')).toBeInTheDocument();
+    expect(screen.getByText('second policy')).toBeInTheDocument();
+    expect(screen.getByText('first content')).toBeInTheDocument();
+    expect(screen.getByText('second content')).toBeInTheDocument();
+    const pageItems = container.querySelector('.pf-c-pagination__total-items');
+    expect(within(pageItems).getByText(/1 - 2/)).toBeInTheDocument();
+    expect(within(pageItems).getByText('of')).toBeInTheDocument();
+    expect(within(pageItems).getByText('2')).toBeInTheDocument();
+  });
+  it('should load page with page params', async () => {
+    const { container } = render(
+      <TestComponent history={pageParamsHistoryMock} mocks={pageParamsMocks} />
+    );
+    await waitFor(tick);
+    const pageItems = container.querySelector('.pf-c-pagination__total-items');
+    expect(within(pageItems).getByText(/6 - 7/)).toBeInTheDocument();
+    expect(within(pageItems).getByText('of')).toBeInTheDocument();
+    expect(within(pageItems).getByText('7')).toBeInTheDocument();
+    userEvent.click(
+      screen.getByRole('button', { name: 'Go to previous page' })
+    );
+
+    expect(pushMock).toHaveBeenCalledWith(
+      `${ovalPoliciesPath}?page=1&perPage=5`
+    );
+  });
+  it('should show empty state', async () => {
+    render(<TestComponent history={historyMock} mocks={emptyMocks} />);
+    expect(screen.getByText('Loading')).toBeInTheDocument();
+    await waitFor(tick);
+    expect(screen.queryByText('Loading')).not.toBeInTheDocument();
+    expect(screen.getByText('No OVAL Policies found')).toBeInTheDocument();
+  });
+  it('should show errors', async () => {
+    render(<TestComponent history={historyMock} mocks={errorMocks} />);
+    expect(screen.getByText('Loading')).toBeInTheDocument();
+    await waitFor(tick);
+    expect(screen.queryByText('Loading')).not.toBeInTheDocument();
+    expect(
+      screen.getByText('Something very bad happened.')
+    ).toBeInTheDocument();
+    expect(screen.getByText('Error!')).toBeInTheDocument();
+  });
+  it('should load page for user with permissions', async () => {
+    render(<TestComponent history={historyMock} mocks={viewerMocks} />);
+    await waitFor(tick);
+    expect(screen.queryByText('Loading')).not.toBeInTheDocument();
+    expect(screen.getByText('first policy')).toBeInTheDocument();
+  });
+  it('should not load page for user without permissions', async () => {
+    render(<TestComponent history={historyMock} mocks={unauthorizedMocks} />);
+    await waitFor(tick);
+    expect(screen.queryByText('Loading')).not.toBeInTheDocument();
+    expect(screen.queryByText('first policy')).not.toBeInTheDocument();
+    expect(
+      screen.getByText(
+        'You are not authorized to view the page. Request the following permissions from administrator: view_oval_policies.'
+      )
+    ).toBeInTheDocument();
+    expect(screen.getByText('Permission denied')).toBeInTheDocument();
+  });
+});

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

@@ -0,0 +1,7 @@
+import React from 'react';
+
+import OvalPoliciesIndex from './OvalPoliciesIndex';
+
+const WrappedOvalPoliciesIndex = props => <OvalPoliciesIndex {...props} />;
+
+export default WrappedOvalPoliciesIndex;

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

@@ -0,0 +1,49 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { translate as __ } from 'foremanReact/common/I18n';
+
+import { useQuery } from '@apollo/client';
+
+import CvesTable from './CvesTable';
+
+import cves from '../../../graphql/queries/cves.gql';
+import {
+  useParamsToVars,
+  useCurrentPagination,
+} from '../../../helpers/pageParamsHelper';
+
+const CvesTab = props => {
+  const useFetchFn = componentProps =>
+    useQuery(cves, {
+      variables: {
+        search: `oval_policy_id = ${componentProps.match.params.id}`,
+        ...useParamsToVars(componentProps.history),
+      },
+    });
+
+  const renameData = data => ({
+    cves: data.cves.nodes,
+    totalCount: data.cves.totalCount,
+  });
+
+  const pagination = useCurrentPagination(props.history);
+
+  return (
+    <CvesTable
+      {...props}
+      fetchFn={useFetchFn}
+      renameData={renameData}
+      resultPath="cves.nodes"
+      pagination={pagination}
+      emptyStateTitle={__('No CVEs found.')}
+      permissions={['view_oval_policies']}
+    />
+  );
+};
+
+CvesTab.propTypes = {
+  match: PropTypes.object.isRequired,
+  history: PropTypes.object.isRequired,
+};
+
+export default CvesTab;

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,78 @@
+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 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,87 @@
+import { mockFactory, admin, intruder } 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,
+  { currentUser: admin }
+);
+
+export const policyUnauthorizedMock = policyDetailMockFactory(
+  { id: ovalPolicy.id },
+  ovalPolicy,
+  { currentUser: intruder }
+);
+
+export const policyCvesMock = cvesMockFactory(
+  { search: `oval_policy_id = ${ovalPolicyId}`, first: 5, last: 5 },
+  cvesResult,
+  { currentUser: admin }
+);

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

@@ -0,0 +1,129 @@
+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,
+  policyUnauthorizedMock,
+} 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 not load the page when user does not have permissions', async () => {
+    render(
+      <TestComponent
+        history={historyMock}
+        match={{ params: { id: ovalPolicyId }, path: ovalPoliciesShowPath }}
+        mocks={policyUnauthorizedMock}
+      />
+    );
+    await waitFor(tick);
+    expect(screen.queryByText('Loading')).not.toBeInTheDocument();
+    expect(
+      screen.getByText(
+        'You are not authorized to view the page. Request the following permissions from administrator: view_oval_policies.'
+      )
+    ).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'
+    );
+  });
+});