foreman_openscap 5.1.0 → 5.2.0

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

@@ -0,0 +1,135 @@
+import React, { useState } from 'react';
+import PropTypes from 'prop-types';
+import { useLazyQuery } from '@apollo/client';
+import { translate as __, sprintf } from 'foremanReact/common/I18n';
+import {
+  Select,
+  SelectOption,
+  SelectVariant,
+  FormGroup,
+} from '@patternfly/react-core';
+import { ExclamationCircleIcon } from '@patternfly/react-icons';
+import hostgroupsQuery from '../../../graphql/queries/hostgroups.gql';
+
+const HostgroupSelect = ({
+  selected,
+  setSelected,
+  hgsError,
+  showError,
+  setShowError,
+}) => {
+  const [isOpen, setIsOpen] = useState(false);
+
+  const [typingTimeout, setTypingTimeout] = useState(null);
+
+  const [fetchHostgroups, { loading, data, error }] = useLazyQuery(
+    hostgroupsQuery
+  );
+  const results = data?.hostgroups?.nodes ? data.hostgroups.nodes : [];
+
+  const onSelect = (event, selection) => {
+    if (selected.find(item => item.name === selection)) {
+      setSelected(selected.filter(item => item.name !== selection));
+    } else {
+      const hg = results.find(item => item.name === selection);
+      setSelected([...selected, hg]);
+    }
+  };
+
+  const onClear = () => {
+    if (showError) {
+      setShowError(false);
+    }
+    setSelected([]);
+  };
+
+  const onInputChange = value => {
+    if (showError) {
+      setShowError(false);
+    }
+    if (typingTimeout) {
+      clearTimeout(typingTimeout);
+    }
+    const variables = { search: `name ~ ${value}` };
+    setTypingTimeout(setTimeout(() => fetchHostgroups({ variables }), 500));
+  };
+
+  const shouldValidate = (err, shouldShowError) => {
+    if (shouldShowError) {
+      return err ? 'error' : 'success';
+    }
+    return 'noval';
+  };
+
+  const prepareOptions = fetchedResults => {
+    if (loading) {
+      return [
+        <SelectOption isDisabled key={0}>
+          {__('Loading...')}
+        </SelectOption>,
+      ];
+    }
+
+    if (error) {
+      return [
+        <SelectOption isDisabled key={0}>
+          {sprintf('Failed to fetch hostgroups, cause: %s', error.message)}
+        </SelectOption>,
+      ];
+    }
+
+    if (fetchedResults.length > 20) {
+      return [
+        <SelectOption isDisabled key={0}>
+          {sprintf(
+            'You have %s hostgroups to display. Please refine your search.',
+            fetchedResults.length
+          )}
+        </SelectOption>,
+      ];
+    }
+
+    return fetchedResults.map((hg, idx) => (
+      <SelectOption key={hg.id} value={hg.name} />
+    ));
+  };
+
+  return (
+    <FormGroup
+      label={__('Hostgroups')}
+      helperTextInvalidIcon={<ExclamationCircleIcon />}
+      helperTextInvalid={showError && hgsError}
+      validated={shouldValidate(hgsError, showError)}
+    >
+      <Select
+        variant={SelectVariant.typeaheadMulti}
+        typeAheadAriaLabel="Select a hostgroup"
+        placeholderText="Type a hostroup name..."
+        onToggle={() => setIsOpen(!isOpen)}
+        onSelect={onSelect}
+        onClear={onClear}
+        selections={selected.map(item => item.name)}
+        isOpen={isOpen}
+        onTypeaheadInputChanged={onInputChange}
+        validated={shouldValidate(hgsError, showError)}
+      >
+        {prepareOptions(results)}
+      </Select>
+    </FormGroup>
+  );
+};
+
+HostgroupSelect.propTypes = {
+  selected: PropTypes.array,
+  setSelected: PropTypes.func.isRequired,
+  hgsError: PropTypes.string,
+  showError: PropTypes.bool.isRequired,
+  setShowError: PropTypes.func.isRequired,
+};
+
+HostgroupSelect.defaultProps = {
+  selected: [],
+  hgsError: '',
+};
+
+export default HostgroupSelect;

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 }
+);