foreman_openscap 5.1.0 → 5.1.1

data/webpack/routes/OvalPolicies/OvalPoliciesNew/NewOvalPolicyForm.js

@@ -0,0 +1,119 @@
+import React, { useState } from 'react';
+import PropTypes from 'prop-types';
+import { Formik, Field as FormikField } from 'formik';
+import { useMutation } from '@apollo/client';
+import { translate as __ } from 'foremanReact/common/I18n';
+import { Button, Form as PfForm, ActionGroup } from '@patternfly/react-core';
+
+import createOvalPolicy from '../../../graphql/mutations/createOvalPolicy.gql';
+
+import {
+  TextField,
+  TextAreaField,
+  SelectField,
+} from '../../../helpers/formFieldsHelper';
+import HostgroupSelect from './HostgroupSelect';
+import withLoading from '../../../components/withLoading';
+
+import { ovalPoliciesPath } from '../../../helpers/pathsHelper';
+import LinkButton from '../../../components/LinkButton';
+
+import {
+  createValidationSchema,
+  onSubmit,
+  initialValues,
+} from './NewOvalPolicyFormHelpers';
+
+const NewOvalPolicyForm = ({ history, showToast, ovalContents }) => {
+  const [callMutation] = useMutation(createOvalPolicy);
+
+  const [assignedHgs, setAssignedHgs] = useState([]);
+  const [hgsShowError, setHgsShowError] = useState(false);
+  const [hgsError, setHgsError] = useState('');
+
+  const onHgsError = error => {
+    setHgsShowError(true);
+    setHgsError(error);
+  };
+
+  return (
+    <Formik
+      onSubmit={onSubmit(
+        history,
+        showToast,
+        callMutation,
+        assignedHgs,
+        onHgsError
+      )}
+      initialValues={initialValues}
+      validationSchema={createValidationSchema()}
+    >
+      {formProps => (
+        <PfForm>
+          <FormikField
+            name="name"
+            component={TextField}
+            label={__('Name')}
+            isRequired
+          />
+          <FormikField
+            name="description"
+            component={TextAreaField}
+            label={__('Description')}
+          />
+          <FormikField
+            name="cronLine"
+            component={TextField}
+            label={__('Schedule')}
+            isRequired
+          />
+          <FormikField
+            name="ovalContentId"
+            component={SelectField}
+            selectItems={ovalContents}
+            label={__('OVAL Content')}
+            isRequired
+            blankLabel={__('Choose OVAL Content')}
+          />
+          <HostgroupSelect
+            selected={assignedHgs}
+            setSelected={setAssignedHgs}
+            showError={hgsShowError}
+            setShowError={setHgsShowError}
+            hgsError={hgsError}
+            isDisabled={formProps.isSubmitting}
+          />
+          <ActionGroup>
+            <Button
+              variant="primary"
+              onClick={formProps.handleSubmit}
+              isDisabled={
+                !formProps.isValid ||
+                formProps.isSubmitting ||
+                (hgsShowError && hgsError)
+              }
+              aria-label="submit"
+            >
+              {__('Submit')}
+            </Button>
+            <LinkButton
+              path={ovalPoliciesPath}
+              btnVariant="link"
+              btnText={__('Cancel')}
+              btnAriaLabel="cancel"
+              isDisabled={formProps.isSubmitting}
+            />
+          </ActionGroup>
+        </PfForm>
+      )}
+    </Formik>
+  );
+};
+
+NewOvalPolicyForm.propTypes = {
+  history: PropTypes.object.isRequired,
+  showToast: PropTypes.func.isRequired,
+  ovalContents: PropTypes.array.isRequired,
+};
+
+export default withLoading(NewOvalPolicyForm);

data/webpack/routes/OvalPolicies/OvalPoliciesNew/NewOvalPolicyFormHelpers.js

@@ -0,0 +1,107 @@
+import * as Yup from 'yup';
+import { translate as __ } from 'foremanReact/common/I18n';
+
+import { ovalPoliciesPath } from '../../../helpers/pathsHelper';
+import { decodeId, decodeModelId } from '../../../helpers/globalIdHelper';
+
+export const createValidationSchema = () => {
+  const cantBeBlank = __("can't be blank");
+
+  return Yup.object().shape({
+    name: Yup.string().required(cantBeBlank),
+    ovalContentId: Yup.string().required(cantBeBlank),
+    cronLine: Yup.string().test(
+      'is-cron',
+      __('is not a valid cronline'),
+      value => value && value.trim().split(' ').length === 5
+    ),
+  });
+};
+
+const partitionById = (array, name) => {
+  const res = array.reduce(
+    (memo, item) => {
+      if (item.id === name) {
+        memo.left.push(item);
+      } else {
+        memo.right.push(item);
+      }
+      return memo;
+    },
+    { left: [], right: [] }
+  );
+  return [res.left, res.right];
+};
+
+const checksToMessage = checks =>
+  checks.reduce((memo, check) => [...memo, check.failMsg], []).join(' ');
+
+export const onSubmit = (
+  history,
+  showToast,
+  callMutation,
+  assignedHgs,
+  setHgsError
+) => (values, actions) => {
+  const onCompleted = response => {
+    const failedChecks = response.data.createOvalPolicy.checkCollection.filter(
+      check => check.result === 'fail'
+    );
+    if (failedChecks.length === 0) {
+      history.push(ovalPoliciesPath);
+      showToast({
+        type: 'success',
+        message: 'OVAL Policy succesfully created.',
+      });
+    } else {
+      actions.setSubmitting(false);
+
+      const [validationChecks, withoutValidationChecks] = partitionById(
+        failedChecks,
+        'oval_policy_errors'
+      );
+
+      const [hgChecks, remainingChecks] = partitionById(
+        withoutValidationChecks,
+        'hostgroups_without_proxy'
+      );
+      if (validationChecks.length === 1) {
+        actions.setErrors(validationChecks[0].errors);
+      }
+      if (hgChecks.length > 0) {
+        setHgsError(checksToMessage(hgChecks));
+      }
+      if (remainingChecks.length > 0) {
+        showToast({
+          type: 'error',
+          message: checksToMessage(remainingChecks),
+        });
+      }
+    }
+  };
+
+  const onError = response => {
+    showToast({
+      type: 'error',
+      message: `Failed to create OVAL Policy: ${response.error}`,
+    });
+    actions.setSubmitting(false);
+  };
+
+  const hostgroupIds = assignedHgs.map(decodeModelId);
+  const variables = {
+    ...values,
+    ovalContentId: decodeId(values.ovalContentId),
+    period: 'custom',
+    hostgroupIds,
+  };
+  // eslint-disable-next-line promise/prefer-await-to-then
+  callMutation({ variables }).then(onCompleted, onError);
+};
+
+export const initialValues = {
+  name: '',
+  description: '',
+  ovalContentId: '',
+  cronLine: '',
+};

data/webpack/routes/OvalPolicies/OvalPoliciesNew/OvalPoliciesNew.js

@@ -0,0 +1,32 @@
+import React from 'react';
+import { useQuery } from '@apollo/client';
+import { translate as __ } from 'foremanReact/common/I18n';
+import IndexLayout from '../../../components/IndexLayout';
+
+import ovalContentsQuery from '../../../graphql/queries/ovalContents.gql';
+import NewOvalPolicyForm from './NewOvalPolicyForm';
+
+const OvalPoliciesNew = props => {
+  const useFetchFn = () => useQuery(ovalContentsQuery);
+
+  const renameData = data => ({
+    ovalContents: data.ovalContents.nodes,
+  });
+
+  return (
+    <IndexLayout pageTitle={__('Create OVAL Policy')}>
+      <NewOvalPolicyForm
+        fetchFn={useFetchFn}
+        renameData={renameData}
+        resultPath="ovalContents.nodes"
+        emptyStateTitle={__('No OVAL Content found')}
+        emptyStateBody={__(
+          'OVAL Content is required to create OVAL Policy. Please create one before proceeding.'
+        )}
+        {...props}
+      />
+    </IndexLayout>
+  );
+};
+
+export default OvalPoliciesNew;

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

@@ -0,0 +1,147 @@
+import createOvalPolicy from '../../../../graphql/mutations/createOvalPolicy.gql';
+import hostgroupsQuery from '../../../../graphql/queries/hostgroups.gql';
+
+import { mockFactory, admin } from '../../../../testHelper';
+import { decodeId } from '../../../../helpers/globalIdHelper';
+import { ovalContents } from '../../../OvalContents/OvalContentsIndex/__tests__/OvalContentsIndex.fixtures';
+
+export const newPolicyName = 'test policy';
+export const newPolicyDescription = 'random description';
+export const newPolicyCronline = '5 5 5 5 5';
+export const newPolicyContentName = ovalContents.nodes[1].name;
+export const newPolicyContentId = ovalContents.nodes[1].id;
+const hostgroupId = 3;
+
+const createPolicyMockFactory = mockFactory(
+  'createOvalPolicy',
+  createOvalPolicy
+);
+const hostgroupsMockFactory = mockFactory('hostgroups', hostgroupsQuery);
+
+const foremanAnsiblePresent = {
+  id: 'foreman_ansible_present',
+  errors: null,
+  failMsg: null,
+  result: 'pass',
+};
+const rolePresent = {
+  id: 'foreman_scap_client_role_present',
+  errors: null,
+  failMsg: null,
+  result: 'pass',
+};
+const roleVarsPresent = {
+  id: 'foreman_scap_client_vars_present',
+  errors: null,
+  failMsg: null,
+  result: 'pass',
+};
+const serverVarOverriden = {
+  id: 'foreman_scap_client_server_overriden',
+  errors: null,
+  failMsg: null,
+  result: 'pass',
+};
+const portVarOverriden = {
+  id: 'foreman_scap_client_port_overriden',
+  errors: null,
+  failMsg: null,
+  result: 'pass',
+};
+const policiesVarOverriden = {
+  id: 'foreman_scap_client_policies_overriden',
+  errors: null,
+  failMsg: null,
+  result: 'pass',
+};
+const policyErrors = {
+  id: 'oval_policy_errors',
+  errors: { name: 'has already been taken' },
+  failMsg: null,
+  result: 'fail',
+};
+export const hgWithoutProxy = {
+  id: 'hostgroups_without_proxy',
+  errors: null,
+  failMsg: 'Assign openscap_proxy to first hostgroup before proceeding.',
+  result: 'fail',
+};
+export const roleAbsent = {
+  id: 'foreman_scap_client_role_present',
+  errors: null,
+  failMsg:
+    'theforeman.foreman_scap_client Ansible Role not found, please import it before running this action again.',
+  result: 'fail',
+};
+
+const varChecks = [
+  roleVarsPresent,
+  serverVarOverriden,
+  portVarOverriden,
+  policiesVarOverriden,
+];
+const checkCollectionPass = [foremanAnsiblePresent, rolePresent, ...varChecks];
+const checkCollectionPreconditionFail = [
+  foremanAnsiblePresent,
+  roleAbsent,
+  ...varChecks.map(check => ({ ...check, result: 'skip' })),
+];
+const ovalPolicy = {
+  name: newPolicyName,
+  id: 'MDE6Rm9yZW1hbk9wZW5zY2FwOjpPdmFsUG9saWN5LTcw',
+  period: 'custom',
+  cronLine: newPolicyCronline,
+  hostgroups: {
+    nodes: [],
+  },
+};
+
+const policyCreateSuccess = {
+  checkCollection: checkCollectionPass,
+  ovalPolicy,
+};
+
+const baseVariables = {
+  name: newPolicyName,
+  description: '',
+  ovalContentId: decodeId(newPolicyContentId),
+  cronLine: newPolicyCronline,
+  hostgroupIds: [],
+  period: 'custom',
+};
+
+export const firstHg = {
+  id: 'MDE6SG9zdGdyb3VwLTM=',
+  name: 'first hostgroup',
+};
+
+const successVariables = {
+  ...baseVariables,
+  description: newPolicyDescription,
+};
+
+export const policySuccessMock = createPolicyMockFactory(
+  successVariables,
+  policyCreateSuccess
+);
+
+export const policyValidationMock = createPolicyMockFactory(baseVariables, {
+  checkCollection: [...checkCollectionPass, policyErrors],
+  ovalPolicy,
+});
+
+export const policyPreconditionMock = createPolicyMockFactory(baseVariables, {
+  checkCollection: checkCollectionPreconditionFail,
+  ovalPolicy,
+});
+
+export const policyInvalidHgMock = createPolicyMockFactory(
+  { ...baseVariables, hostgroupIds: [hostgroupId] },
+  { checkCollection: [...checkCollectionPass, hgWithoutProxy], ovalPolicy }
+);
+
+export const hostgroupsMock = hostgroupsMockFactory(
+  { search: `name ~ first` },
+  { totalCount: 2, nodes: [firstHg] },
+  { currentUser: admin }
+);

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

@@ -0,0 +1,172 @@
+import React from 'react';
+import { render, screen } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import userEvent from '@testing-library/user-event';
+
+import OvalPoliciesNew from '../';
+import { ovalPoliciesPath } from '../../../../helpers/pathsHelper';
+
+import { unpagedMocks as ovalContentMocks } from '../../../OvalContents/OvalContentsIndex/__tests__/OvalContentsIndex.fixtures';
+
+import {
+  withMockedProvider,
+  wait,
+  withRouter,
+  withRedux,
+} from '../../../../testHelper';
+
+import {
+  newPolicyName,
+  newPolicyDescription,
+  newPolicyCronline,
+  newPolicyContentName,
+  policySuccessMock,
+  policyValidationMock,
+  policyPreconditionMock,
+  policyInvalidHgMock,
+  hostgroupsMock,
+  firstHg,
+  roleAbsent as roleAbsentCheck,
+  hgWithoutProxy as withoutProxyCheck,
+} from './OvalPoliciesNew.fixtures';
+
+import * as toasts from '../../../../helpers/toastsHelper';
+
+const TestComponent = withRouter(
+  withRedux(withMockedProvider(OvalPoliciesNew))
+);
+
+describe('OvalPoliciesNew', () => {
+  it('should create new OVAL policy', async () => {
+    const showToast = jest.fn();
+    jest.spyOn(toasts, 'showToast').mockImplementation(() => showToast);
+    const pushMock = jest.fn();
+
+    render(
+      <TestComponent
+        mocks={ovalContentMocks.concat(policySuccessMock)}
+        history={{
+          push: pushMock,
+        }}
+      />
+    );
+    expect(screen.getByText('Loading')).toBeInTheDocument();
+    await wait();
+    const submitBtn = screen.getByRole('button', { name: 'submit' });
+    expect(submitBtn).toBeDisabled();
+    userEvent.type(screen.getByLabelText(/name/), newPolicyName);
+    await wait();
+    expect(submitBtn).toBeDisabled();
+    userEvent.type(screen.getByLabelText(/cronLine/), 'foo');
+    userEvent.type(screen.getByLabelText(/description/), newPolicyDescription);
+    userEvent.selectOptions(
+      screen.getByLabelText(/ovalContentId/),
+      newPolicyContentName
+    );
+    await wait();
+    expect(screen.getByText('is not a valid cronline')).toBeInTheDocument();
+    expect(submitBtn).toBeDisabled();
+    userEvent.clear(screen.getByLabelText(/cronLine/));
+    userEvent.type(screen.getByLabelText(/cronLine/), newPolicyCronline);
+    await wait();
+    expect(
+      screen.queryByText('is not a valid cronline')
+    ).not.toBeInTheDocument();
+    expect(submitBtn).not.toBeDisabled();
+    userEvent.click(submitBtn);
+    await wait(2);
+    expect(pushMock).toHaveBeenCalledWith(ovalPoliciesPath);
+    expect(showToast).toHaveBeenCalledWith({
+      type: 'success',
+      message: 'OVAL Policy succesfully created.',
+    });
+  });
+  it('should not create new policy on validation error', async () => {
+    const showToast = jest.fn();
+    jest.spyOn(toasts, 'showToast').mockImplementation(() => showToast);
+    const pushMock = jest.fn();
+
+    render(
+      <TestComponent
+        mocks={ovalContentMocks.concat(policyValidationMock)}
+        history={{
+          push: pushMock,
+        }}
+      />
+    );
+    await wait();
+    userEvent.type(screen.getByLabelText(/name/), newPolicyName);
+    userEvent.type(screen.getByLabelText(/cronLine/), newPolicyCronline);
+    userEvent.selectOptions(
+      screen.getByLabelText(/ovalContentId/),
+      newPolicyContentName
+    );
+    await wait();
+    userEvent.click(screen.getByRole('button', { name: 'submit' }));
+    await wait(2);
+    expect(pushMock).not.toHaveBeenCalled();
+    expect(showToast).not.toHaveBeenCalled();
+    expect(screen.getByText('has already been taken')).toBeInTheDocument();
+  });
+  it('should not create policy on preconditions error', async () => {
+    const showToast = jest.fn();
+    jest.spyOn(toasts, 'showToast').mockImplementation(() => showToast);
+    const pushMock = jest.fn();
+
+    render(
+      <TestComponent
+        mocks={ovalContentMocks.concat(policyPreconditionMock)}
+        history={{
+          push: pushMock,
+        }}
+      />
+    );
+    await wait();
+    userEvent.type(screen.getByLabelText(/name/), newPolicyName);
+    userEvent.type(screen.getByLabelText(/cronLine/), newPolicyCronline);
+    userEvent.selectOptions(
+      screen.getByLabelText(/ovalContentId/),
+      newPolicyContentName
+    );
+    await wait();
+    userEvent.click(screen.getByRole('button', { name: 'submit' }));
+    await wait(2);
+    await wait();
+    expect(pushMock).not.toHaveBeenCalled();
+    expect(showToast).toHaveBeenCalledWith({
+      type: 'error',
+      message: roleAbsentCheck.failMsg,
+    });
+  });
+  it('should show hostgroup errros', async () => {
+    const showToast = jest.fn();
+    jest.spyOn(toasts, 'showToast').mockImplementation(() => showToast);
+    const pushMock = jest.fn();
+
+    render(
+      <TestComponent
+        mocks={ovalContentMocks
+          .concat(policyInvalidHgMock)
+          .concat(hostgroupsMock)}
+        history={{
+          push: pushMock,
+        }}
+      />
+    );
+    await wait();
+    userEvent.type(screen.getByLabelText(/name/), newPolicyName);
+    userEvent.type(screen.getByLabelText(/cronLine/), newPolicyCronline);
+    userEvent.selectOptions(
+      screen.getByLabelText(/ovalContentId/),
+      newPolicyContentName
+    );
+    userEvent.type(screen.getByLabelText(/hostgroup/), 'first');
+    await wait(500);
+    userEvent.click(screen.getByText(firstHg.name));
+    await wait();
+    userEvent.click(screen.getByRole('button', { name: 'submit' }));
+    await wait(2);
+    expect(pushMock).not.toHaveBeenCalled();
+    expect(screen.getByText(withoutProxyCheck.failMsg)).toBeInTheDocument();
+  });
+});

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

@@ -0,0 +1,11 @@
+import React from 'react';
+import { useDispatch } from 'react-redux';
+
+import { showToast } from '../../../helpers/toastsHelper';
+import OvalPoliciesNew from './OvalPoliciesNew';
+
+const WrappedOvalPoliciesNew = props => (
+  <OvalPoliciesNew {...props} showToast={showToast(useDispatch())} />
+);
+
+export default WrappedOvalPoliciesNew;

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

@@ -4,7 +4,7 @@ import { translate as __ } from 'foremanReact/common/I18n';
 
 import { linkCell } from '../../../helpers/tableHelper';
 import { hostsPath } from '../../../helpers/pathsHelper';
-import { decodeId } from '../../../helpers/globalIdHelper';
+import { decodeModelId } from '../../../helpers/globalIdHelper';
 import { addSearch } from '../../../helpers/pageParamsHelper';
 
 import withLoading from '../../../components/withLoading';
@@ -25,7 +25,7 @@ const CvesTable = props => {
 
   const hostCount = cve =>
     linkCell(
-      addSearch(hostsPath, { search: `cve_id = ${decodeId(cve)}` }),
+      addSearch(hostsPath, { search: `cve_id = ${decodeModelId(cve)}` }),
       cve.hosts.nodes.length
     );
 

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

@@ -40,6 +40,7 @@ const DetailsTab = props => {
             onConfirm={onAttrUpdate('name', policy, callMutation, showToast)}
             component={TextInput}
             attrName="name"
+            allowed={policy.meta.canEdit}
           />
         </TextListItem>
         <TextListItem component={TextListItemVariants.dt}>
@@ -70,6 +71,7 @@ const DetailsTab = props => {
             )}
             component={TextArea}
             attrName="description"
+            allowed={policy.meta.canEdit}
           />
         </TextListItem>
       </TextList>

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

@@ -1,6 +1,5 @@
 import { translate as __, sprintf } from 'foremanReact/common/I18n';
-
-import { decodeId } from '../../../helpers/globalIdHelper';
+import { decodeModelId } from '../../../helpers/globalIdHelper';
 import { addSearch } from '../../../helpers/pageParamsHelper';
 import { newJobPath } from '../../../helpers/pathsHelper';
 
@@ -19,7 +18,9 @@ export const policySchedule = policy => {
 
 const targetingScopedSearchQuery = policy => {
   const hgIds = policy.hostgroups.nodes.reduce((memo, hg) => {
-    const ids = [decodeId(hg)].concat(hg.descendants.nodes.map(decodeId));
+    const ids = [decodeModelId(hg)].concat(
+      hg.descendants.nodes.map(decodeModelId)
+    );
     return ids.reduce(
       (acc, id) => (acc.includes(id) ? acc : [...acc, id]),
       memo

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

@@ -9,6 +9,7 @@ import {
   historyMock,
   ovalPolicyId,
   policyDetailMock,
+  policyEditPermissionsMock,
   ovalPolicy,
 } from './OvalPoliciesShow.fixtures';
 import {
@@ -171,5 +172,31 @@ describe('OvalPoliciesShow', () => {
     ).not.toBeInTheDocument();
     expect(screen.getByText(ovalPolicy.name)).toBeInTheDocument();
     expect(screen.getByText('has already been taken')).toBeInTheDocument();
+    userEvent.click(
+      screen.getByRole('button', { name: 'cancel editing name' })
+    );
+    userEvent.click(editBtn);
+    expect(
+      screen.queryByText('has already been taken')
+    ).not.toBeInTheDocument();
+  });
+  it('should not show edit btns when user is not allowed to edit', async () => {
+    render(
+      <TestComponent
+        history={historyMock}
+        match={{
+          params: { id: ovalPolicyId, tab: 'details' },
+          path: ovalPoliciesShowPath,
+        }}
+        mocks={policyEditPermissionsMock}
+      />
+    );
+    await waitFor(tick);
+    expect(
+      screen.queryByRole('button', { name: 'edit name' })
+    ).not.toBeInTheDocument();
+    expect(
+      screen.queryByRole('button', { name: 'edit description' })
+    ).not.toBeInTheDocument();
   });
 });