foreman_ansible 6.4.1 → 7.0.0

data/webpack/components/AnsibleHostDetail/components/AnsibleVariableOverrides/__test__/AnsibleVariableOverridesDelete.test.js

@@ -0,0 +1,74 @@
+import React from 'react';
+import { render, screen, waitFor } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import userEvent from '@testing-library/user-event';
+
+import {
+  withRedux,
+  withMockedProvider,
+  tick,
+  historyMock,
+} from '../../../../../testHelper';
+import {
+  deleteMocks,
+  mocks,
+  hostId,
+  hostAttrs,
+} from './AnsibleVariableOverrides.fixtures';
+
+import * as toasts from '../../../../../toastHelper';
+
+import AnsibleVariableOverrides from '../';
+
+const TestComponent = withRedux(withMockedProvider(AnsibleVariableOverrides));
+
+describe('AnsibleVariableOverrides', () => {
+  it('should open and close delete modal', async () => {
+    render(
+      <TestComponent
+        mocks={mocks}
+        hostId={hostId}
+        hostAttrs={hostAttrs}
+        history={historyMock}
+      />
+    );
+    await waitFor(tick);
+    userEvent.click(screen.getAllByRole('button', { name: 'Actions' })[0]);
+    userEvent.click(screen.getByText('Delete'));
+    await waitFor(tick);
+    expect(
+      screen.getByText('Delete Ansible Variable Override')
+    ).toBeInTheDocument();
+    userEvent.click(screen.getByText('Cancel'));
+    await waitFor(tick);
+    expect(
+      screen.queryByText('Delete Ansible Variable Override')
+    ).not.toBeInTheDocument();
+  });
+  it('should delete override', async () => {
+    const showToast = jest.fn();
+    jest.spyOn(toasts, 'showToast').mockImplementation(showToast);
+    render(
+      <TestComponent
+        mocks={mocks.concat(deleteMocks)}
+        hostId={hostId}
+        hostAttrs={hostAttrs}
+        history={historyMock}
+      />
+    );
+    await waitFor(tick);
+    expect(screen.queryByText('21')).toBeInTheDocument();
+    userEvent.click(screen.getAllByRole('button', { name: 'Actions' })[0]);
+    userEvent.click(screen.getByText('Delete'));
+    await waitFor(tick);
+    userEvent.click(screen.getByText('Confirm'));
+    await waitFor(tick);
+    expect(showToast).toHaveBeenCalledWith({
+      type: 'success',
+      message: 'Ansible variable override was successfully deleted.',
+    });
+    await waitFor(tick);
+    expect(screen.queryByText('21')).not.toBeInTheDocument();
+    expect(screen.queryByText('101')).toBeInTheDocument();
+  });
+});

data/webpack/components/AnsibleHostDetail/components/AnsibleVariableOverrides/__test__/AnsibleVariableOverridesUpdate.test.js

@@ -0,0 +1,188 @@
+import React from 'react';
+import { render, screen, waitFor } from '@testing-library/react';
+import '@testing-library/jest-dom';
+import userEvent from '@testing-library/user-event';
+
+import {
+  withRedux,
+  withMockedProvider,
+  tick,
+  historyMock,
+} from '../../../../../testHelper';
+import {
+  mocks,
+  updateMocks,
+  createMocks,
+  updateErrorMocks,
+  updateValidationMocks,
+  hostId,
+  hostAttrs,
+} from './AnsibleVariableOverrides.fixtures';
+
+import * as toasts from '../../../../../toastHelper';
+
+import AnsibleVariableOverrides from '../';
+
+const TestComponent = withRedux(withMockedProvider(AnsibleVariableOverrides));
+
+describe('AnsibleVariableOverrides', () => {
+  it('edit existing override', async () => {
+    const showToast = jest.fn();
+    jest.spyOn(toasts, 'showToast').mockImplementation(showToast);
+
+    render(
+      <TestComponent
+        mocks={mocks.concat(updateMocks)}
+        hostId={hostId}
+        hostAttrs={hostAttrs}
+        history={historyMock}
+      />
+    );
+
+    await waitFor(tick);
+    expect(screen.getByText('21')).toBeInTheDocument();
+    userEvent.click(
+      screen.getAllByRole('button', { name: 'Edit override button' })[0]
+    );
+    userEvent.type(
+      screen.getByRole('textbox', { name: 'Edit override field' }),
+      '77'
+    );
+    userEvent.click(
+      screen.getAllByRole('button', {
+        name: 'Submit editing override button',
+      })[0]
+    );
+    await waitFor(tick);
+    expect(showToast).toHaveBeenCalledWith({
+      type: 'success',
+      message: 'Ansible variable override successfully changed.',
+    });
+    expect(screen.queryByText('21')).not.toBeInTheDocument();
+    expect(screen.getByText('2177')).toBeInTheDocument();
+  });
+  it('should show unexpected errors', async () => {
+    const showToast = jest.fn();
+    jest.spyOn(toasts, 'showToast').mockImplementation(showToast);
+
+    render(
+      <TestComponent
+        mocks={mocks.concat(updateErrorMocks)}
+        hostId={hostId}
+        hostAttrs={hostAttrs}
+        history={historyMock}
+      />
+    );
+    await waitFor(tick);
+    userEvent.click(
+      screen.getAllByRole('button', { name: 'Edit override button' })[0]
+    );
+    userEvent.type(
+      screen.getByRole('textbox', { name: 'Edit override field' }),
+      '77'
+    );
+    userEvent.click(
+      screen.getAllByRole('button', {
+        name: 'Submit editing override button',
+      })[0]
+    );
+    await waitFor(tick);
+    expect(showToast).toHaveBeenCalledWith({
+      type: 'error',
+      message:
+        'There was a following error when changing Ansible variable override: Not enough minerals',
+    });
+    expect(
+      screen.getByRole('textbox', { name: 'Edit override field' })
+    ).toHaveValue('2177');
+    userEvent.click(
+      screen.getAllByRole('button', {
+        name: 'Cancel editing override button',
+      })[0]
+    );
+    expect(screen.getByText('21')).toBeInTheDocument();
+  });
+  it('should show client validations', async () => {
+    render(
+      <TestComponent
+        mocks={mocks}
+        hostId={hostId}
+        hostAttrs={hostAttrs}
+        history={historyMock}
+      />
+    );
+    await waitFor(tick);
+    userEvent.click(
+      screen.getAllByRole('button', { name: 'Edit override button' })[1]
+    );
+    const input = screen.getByRole('textbox', { name: 'Edit override field' });
+    const submitBtn = screen.getAllByRole('button', {
+      name: 'Submit editing override button',
+    })[1];
+    userEvent.clear(input);
+    expect(screen.getByText('is required')).toBeInTheDocument();
+    expect(submitBtn).toBeDisabled();
+    userEvent.type(input, 'd');
+    expect(
+      screen.getByText('Invalid, expected one of: a,b,c')
+    ).toBeInTheDocument();
+    expect(submitBtn).toBeDisabled();
+    userEvent.clear(input);
+    userEvent.type(input, 'c');
+    expect(submitBtn).not.toBeDisabled();
+  });
+  it('should show server validations', async () => {
+    render(
+      <TestComponent
+        mocks={mocks.concat(updateValidationMocks)}
+        hostId={hostId}
+        hostAttrs={hostAttrs}
+        history={historyMock}
+      />
+    );
+    await waitFor(tick);
+    userEvent.click(
+      screen.getAllByRole('button', { name: 'Edit override button' })[0]
+    );
+    const input = screen.getByRole('textbox', { name: 'Edit override field' });
+    userEvent.clear(input);
+    userEvent.type(input, 'foo');
+    userEvent.click(
+      screen.getAllByRole('button', {
+        name: 'Submit editing override button',
+      })[0]
+    );
+    await waitFor(tick);
+    expect(screen.getByText('is invalid integer')).toBeInTheDocument();
+  });
+  it('should create new override', async () => {
+    const showToast = jest.fn();
+    jest.spyOn(toasts, 'showToast').mockImplementation(showToast);
+
+    render(
+      <TestComponent
+        mocks={mocks.concat(createMocks)}
+        hostId={hostId}
+        hostAttrs={hostAttrs}
+        history={historyMock}
+      />
+    );
+    await waitFor(tick);
+    userEvent.click(
+      screen.getAllByRole('button', { name: 'Edit override button' })[1]
+    );
+    const input = screen.getByRole('textbox', { name: 'Edit override field' });
+    userEvent.clear(input);
+    userEvent.type(input, 'b');
+    userEvent.click(
+      screen.getAllByRole('button', {
+        name: 'Submit editing override button',
+      })[1]
+    );
+    await waitFor(tick);
+    expect(showToast).toHaveBeenCalledWith({
+      type: 'success',
+      message: 'Ansible variable override successfully changed.',
+    });
+  });
+});

data/webpack/components/AnsibleHostDetail/components/AnsibleVariableOverrides/index.js

@@ -0,0 +1,58 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { translate as __ } from 'foremanReact/common/I18n';
+
+import { useQuery } from '@apollo/client';
+import variableOverrides from '../../../../graphql/queries/hostVariableOverrides.gql';
+import AnsibleVariableOverridesTable from './AnsibleVariableOverridesTable';
+import {
+  useParamsToVars,
+  useCurrentPagination,
+} from '../../../../helpers/pageParamsHelper';
+
+import { encodeId } from '../../../../globalIdHelper';
+import './AnsibleVariableOverrides.scss';
+
+const AnsibleVariableOverrides = ({ hostId, hostAttrs, history }) => {
+  const hostGlobalId = encodeId('Host', hostId);
+  const pagination = useCurrentPagination(history);
+
+  const useFetchFn = () =>
+    useQuery(variableOverrides, {
+      variables: {
+        id: hostGlobalId,
+        match: `fqdn=${hostAttrs.name}`,
+        ...useParamsToVars(history),
+      },
+      fetchPolicy: 'network-only',
+      nextFetchPolicy: 'cache-first',
+    });
+
+  const renameData = data => ({
+    variables: data.host.ansibleVariablesWithOverrides.nodes,
+    totalCount: data.host.ansibleVariablesWithOverrides.totalCount,
+  });
+
+  return (
+    <AnsibleVariableOverridesTable
+      hostId={hostId}
+      hostAttrs={hostAttrs}
+      hostGlobalId={hostGlobalId}
+      renameData={renameData}
+      fetchFn={useFetchFn}
+      renamedDataPath="variables"
+      emptyStateTitle={__('No Ansible Variables found for Host')}
+      permissions={['view_ansible_variables']}
+      pagination={pagination}
+      history={history}
+    />
+  );
+};
+
+AnsibleVariableOverrides.propTypes = {
+  hostId: PropTypes.number.isRequired,
+  hostAttrs: PropTypes.object.isRequired,
+  history: PropTypes.object.isRequired,
+};
+
+export default AnsibleVariableOverrides;

data/webpack/components/AnsibleHostDetail/components/JobsTab/JobsTabHelper.js

@@ -0,0 +1,79 @@
+import { useQuery, useMutation } from '@apollo/client';
+import { translate as __, sprintf } from 'foremanReact/common/I18n';
+import jobsQuery from '../../../../graphql/queries/recurringJobs.gql';
+import cancelRecurringLogic from '../../../../graphql/mutations/cancelRecurringLogic.gql';
+import { showToast } from '../../../../toastHelper';
+
+export const ansiblePurpose = (resourceName, resourceId) =>
+  `ansible-${resourceName}-${resourceId}`;
+
+const jobSearch = (resourceName, resourceId, statusSearch) =>
+  `recurring = true && pattern_template_name = "Ansible Roles - Ansible Default" && ${statusSearch} && recurring_logic.purpose = ${ansiblePurpose(
+    resourceName,
+    resourceId
+  )}`;
+
+export const scheduledJobsSearch = (resourceName, resourceId) =>
+  jobSearch(resourceName, resourceId, 'status = queued');
+export const previousJobsSearch = (resourceName, resourceId) =>
+  jobSearch(resourceName, resourceId, 'status != queued');
+
+const fetchJobsFn = (searchFn, pagination = {}) => componentProps =>
+  useQuery(jobsQuery, {
+    variables: {
+      search: searchFn(componentProps.resourceName, componentProps.resourceId),
+      ...pagination,
+    },
+  });
+
+export const fetchRecurringFn = fetchJobsFn(scheduledJobsSearch);
+export const fetchPreviousFn = pagination =>
+  fetchJobsFn(previousJobsSearch, pagination);
+
+export const renameData = data => ({
+  jobs: data.jobInvocations.nodes,
+  totalCount: data.jobInvocations.totalCount,
+});
+
+export const joinErrors = errors => errors.map(err => err.message).join(', ');
+
+const formatError = error =>
+  sprintf(
+    __('There was a following error when deleting Ansible config job: %s'),
+    error
+  );
+
+const onError = error => {
+  showToast({ type: 'danger', message: formatError(error) });
+};
+
+const onCompleted = data => {
+  const { errors } = data.cancelRecurringLogic;
+  if (Array.isArray(errors) && errors.length > 0) {
+    showToast({
+      type: 'danger',
+      message: formatError(joinErrors(errors)),
+    });
+  } else {
+    showToast({
+      type: 'success',
+      message: __('Ansible job was successfully canceled.'),
+    });
+  }
+};
+
+export const useCancelMutation = (resourceName, resourceId) =>
+  useMutation(cancelRecurringLogic, {
+    onCompleted,
+    onError,
+    refetchQueries: [
+      {
+        query: jobsQuery,
+        variables: { search: previousJobsSearch(resourceName, resourceId) },
+      },
+      {
+        query: jobsQuery,
+        variables: { search: scheduledJobsSearch(resourceName, resourceId) },
+      },
+    ],
+  });

data/webpack/components/AnsibleHostDetail/components/JobsTab/NewRecurringJobHelper.js

@@ -0,0 +1,106 @@
+import * as Yup from 'yup';
+import { translate as __, sprintf } from 'foremanReact/common/I18n';
+
+import { showToast } from '../../../../toastHelper';
+import { ansiblePurpose, joinErrors } from './JobsTabHelper';
+
+export const frequencyOpts = [
+  { id: 'hourly', name: __('hourly') },
+  { id: 'daily', name: __('daily') },
+  { id: 'weekly', name: __('weekly') },
+  { id: 'monthly', name: __('monthly') },
+];
+
+export const rangeValidator = date => {
+  if (date < new Date()) {
+    return __('Must not be in the past');
+  }
+  return '';
+};
+
+export const createValidationSchema = () => {
+  const cantBeBlank = __("can't be blank");
+
+  return Yup.object().shape({
+    repeat: Yup.string().required(cantBeBlank),
+    startTime: Yup.string().required(cantBeBlank),
+    startDate: Yup.string().required(cantBeBlank),
+  });
+};
+
+export const toCron = (date, repeat) => {
+  switch (repeat) {
+    case 'hourly':
+      return `${date.getMinutes()} * * * *`;
+    case 'daily':
+      return `${date.getMinutes()} ${date.getHours()} * * *`;
+    case 'weekly':
+      return `${date.getMinutes()} ${date.getHours()} * * ${date.getDay()}`;
+    case 'monthly':
+      return `${date.getMinutes()} ${date.getHours()} ${date.getDate()} * *`;
+    default:
+      return `${date.getMinutes()} * * * *`;
+  }
+};
+
+export const toVars = (resourceName, resourceId, date, repeat) => {
+  const targeting =
+    resourceName === 'host'
+      ? { hostIds: [resourceId] }
+      : { searchQuery: `hostgroup_id = ${resourceId}` };
+
+  return {
+    variables: {
+      jobInvocation: {
+        ...targeting,
+        feature: 'ansible_run_host',
+        targetingType: 'static_query',
+        scheduling: {
+          startAt: date,
+        },
+        recurrence: {
+          cronLine: toCron(date, repeat),
+          purpose: ansiblePurpose(resourceName, resourceId),
+        },
+      },
+    },
+  };
+};
+
+const formatError = error =>
+  sprintf(
+    __('There was a following error when creating Ansible job: %s'),
+    error
+  );
+
+export const onSubmit = (callMutation, onClose, resourceName, resourceId) => (
+  values,
+  actions
+) => {
+  const onCompleted = response => {
+    actions.setSubmitting(false);
+    const { errors } = response.data.createJobInvocation;
+    if (Array.isArray(errors) && errors.length > 0) {
+      showToast({
+        type: 'danger',
+        message: formatError(joinErrors(errors)),
+      });
+    } else {
+      onClose();
+      showToast({
+        type: 'success',
+        message: __('Ansible job was successfully created.'),
+      });
+    }
+  };
+
+  const onError = error => {
+    actions.setSubmitting(false);
+    showToast({ type: 'danger', message: formatError(error) });
+  };
+
+  const date = new Date(`${values.startDate}T${values.startTime}`);
+  const variables = toVars(resourceName, resourceId, date, values.repeat);
+  // eslint-disable-next-line promise/prefer-await-to-then
+  callMutation(variables).then(onCompleted, onError);
+};

data/webpack/components/AnsibleHostDetail/components/JobsTab/NewRecurringJobModal.js

@@ -0,0 +1,129 @@
+import React 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 {
+  Modal,
+  Button,
+  ModalVariant,
+  Spinner,
+  Form as PfForm,
+} from '@patternfly/react-core';
+import {
+  onSubmit,
+  createValidationSchema,
+  frequencyOpts,
+  rangeValidator,
+} from './NewRecurringJobHelper';
+
+import {
+  DatePickerField,
+  TimePickerField,
+  SelectField,
+} from '../../../../formHelper';
+
+import './NewRecurringJobModal.scss';
+
+import { scheduledJobsSearch } from './JobsTabHelper';
+
+import createJobInvocation from '../../../../graphql/mutations/createJobInvocation.gql';
+import jobsQuery from '../../../../graphql/queries/recurringJobs.gql';
+
+const NewRecurringJobModal = props => {
+  const { onClose, resourceId, resourceName } = props;
+
+  const [callMutation] = useMutation(createJobInvocation, {
+    refetchQueries: [
+      {
+        query: jobsQuery,
+        variables: { search: scheduledJobsSearch(resourceName, resourceId) },
+      },
+    ],
+  });
+
+  return (
+    <Formik
+      validationSchema={createValidationSchema()}
+      onSubmit={onSubmit(callMutation, onClose, resourceName, resourceId)}
+      initialValues={{
+        startTime: '',
+        startDate: '',
+        repeat: '',
+      }}
+    >
+      {formProps => {
+        const actions = [
+          <Button
+            aria-label="submit creating job"
+            key="confirm"
+            variant="primary"
+            onClick={formProps.handleSubmit}
+            isDisabled={formProps.isSubmitting || !formProps.isValid}
+          >
+            {__('Submit')}
+          </Button>,
+          <Button
+            aria-label="cancel creating job"
+            key="cancel"
+            variant="link"
+            onClick={onClose}
+            isDisabled={formProps.isSubmitting}
+          >
+            {__('Cancel')}
+          </Button>,
+        ];
+
+        if (formProps.isSubmitting) {
+          actions.push(<Spinner key="spinner" size="lg" />);
+        }
+
+        return (
+          <Modal
+            variant={ModalVariant.large}
+            title="Create New Recurring Ansible Run"
+            isOpen={props.isOpen}
+            className="foreman-modal modal-high"
+            showClose={false}
+            actions={actions}
+            disableFocusTrap
+          >
+            <PfForm>
+              <FormikField
+                name="repeat"
+                component={SelectField}
+                label="Repeat"
+                isRequired
+                selectItems={frequencyOpts}
+              />
+              <FormikField
+                name="startTime"
+                component={TimePickerField}
+                label="Start Time"
+                isRequired
+                is24Hour
+              />
+              <FormikField
+                name="startDate"
+                component={DatePickerField}
+                label="Start Date"
+                isRequired
+                validators={[rangeValidator]}
+              />
+            </PfForm>
+          </Modal>
+        );
+      }}
+    </Formik>
+  );
+};
+
+NewRecurringJobModal.propTypes = {
+  onClose: PropTypes.func.isRequired,
+  resourceId: PropTypes.number.isRequired,
+  resourceName: PropTypes.string.isRequired,
+  isOpen: PropTypes.bool.isRequired,
+};
+
+export default NewRecurringJobModal;

data/webpack/components/AnsibleHostDetail/components/JobsTab/NewRecurringJobModal.scss

@@ -0,0 +1,7 @@
+.pf-c-backdrop {
+  z-index: 1040;
+}
+
+.modal-high {
+  height: 70%;
+}