foreman_ansible 6.4.1 → 7.0.0

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

@@ -0,0 +1,49 @@
+import { translate as __, sprintf } from 'foremanReact/common/I18n';
+import { showToast } from '../../../../toastHelper';
+
+export const formatError = error =>
+  sprintf(
+    __(
+      'There was a following error when changing Ansible variable override: %s'
+    ),
+    error
+  );
+
+export const joinErrors = errors => errors.map(err => err.message).join(', ');
+
+export const onCompleted = (
+  dataPath,
+  onValidationError,
+  toggleWorking,
+  onSubmitSuccess
+) => data => {
+  const { errors, overridenAnsibleVariable } = data[dataPath];
+  if (Array.isArray(errors) && errors.length > 0) {
+    if (
+      errors.length === 1 &&
+      errors[0].path.join(' ') === 'attributes value'
+    ) {
+      onValidationError(errors[0].message);
+    } else {
+      toggleWorking(false);
+      showToast({
+        type: 'error',
+        message: formatError(joinErrors(errors)),
+      });
+    }
+  } else {
+    onSubmitSuccess(overridenAnsibleVariable.currentValue.value);
+    showToast({
+      type: 'success',
+      message: __('Ansible variable override successfully changed.'),
+    });
+  }
+};
+
+export const onError = toggleWorking => error => {
+  toggleWorking(false);
+  showToast({ type: 'error', message: formatError(error.message) });
+};
+
+export const hasError = state => state.validation.key === 'error';
+export const createMatcher = value => `fqdn=${value}`;

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

@@ -0,0 +1,70 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { translate as __ } from 'foremanReact/common/I18n';
+
+import { formatValue } from './AnsibleVariableOverridesTableHelper';
+
+import {
+  TextAreaField,
+  TextInputField,
+  SelectField,
+} from './EditableValueHelper';
+
+const EditableValue = props => {
+  if (!props.editing) {
+    return formatValue(props.variable);
+  }
+
+  const type = props.variable.parameterType;
+
+  if (type === 'array' || type === 'hash') {
+    return (
+      <TextAreaField
+        onChange={props.onChange}
+        value={props.value}
+        validation={props.validation}
+        isDisabled={props.working}
+      />
+    );
+  }
+
+  if (type === 'boolean') {
+    return (
+      <SelectField
+        selectItems={[
+          { id: 'trueSelectOpt', value: true, name: __('true') },
+          { id: 'falseSelectOpt', value: false, name: __('false') },
+        ]}
+        onChange={props.onChange}
+        validation={props.validation}
+        isDisabled={props.working}
+        value={props.value}
+      />
+    );
+  }
+
+  return (
+    <TextInputField
+      onChange={props.onChange}
+      value={props.value}
+      validation={props.validation}
+      isDisabled={props.working}
+      aria-label="Edit override field"
+    />
+  );
+};
+
+EditableValue.propTypes = {
+  editing: PropTypes.bool.isRequired,
+  variable: PropTypes.object.isRequired,
+  onChange: PropTypes.func.isRequired,
+  value: PropTypes.any,
+  validation: PropTypes.object.isRequired,
+  working: PropTypes.bool.isRequired,
+};
+
+EditableValue.defaultProps = {
+  value: '',
+};
+
+export default EditableValue;

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

@@ -0,0 +1,35 @@
+import React from 'react';
+import {
+  TextInput,
+  TextArea,
+  FormGroup,
+  FormSelect,
+  FormSelectOption,
+} from '@patternfly/react-core';
+
+const withFormGroup = Component => componentProps => {
+  const { validation, ...rest } = componentProps;
+  return (
+    <FormGroup
+      label=""
+      helperTextInvalid={validation.msg}
+      validated={validation.key}
+    >
+      <Component {...rest} validated={validation.key} />
+    </FormGroup>
+  );
+};
+
+export const SelectField = componentProps => {
+  const { selectItems, ...rest } = componentProps;
+  return (
+    <FormSelect className="without_select2" {...rest}>
+      {selectItems.map(item => (
+        <FormSelectOption key={item.id} value={item.value} label={item.name} />
+      ))}
+    </FormSelect>
+  );
+};
+
+export const TextInputField = withFormGroup(TextInput);
+export const TextAreaField = withFormGroup(TextArea);

data/webpack/components/AnsibleHostDetail/components/AnsibleVariableOverrides/__test__/AnsibleVariableOverrides.fixtures.js

@@ -0,0 +1,429 @@
+/* eslint-disable max-lines */
+import variableOverridesQuery from '../../../../../graphql/queries/hostVariableOverrides.gql';
+import deleteAnsibleVariableOverride from '../../../../../graphql/mutations/deleteAnsibleVariableOverride.gql';
+import updateAnsibleVariableOverride from '../../../../../graphql/mutations/updateAnsibleVariableOverride.gql';
+import createAnsibleVariableOverride from '../../../../../graphql/mutations/createAnsibleVariableOverride.gql';
+import { admin } from '../../../../../testHelper';
+
+export const hostId = 3;
+const hostGlobalId = 'MDE6SG9zdC0z';
+const name = 'centos-random.example.com';
+const match = `fqdn=${name}`;
+
+export const hostAttrs = {
+  name,
+};
+
+const overrideUpdateDeleteId = 'MDE6TG9va3VwVmFsdWUtODQ=';
+const ansibleVariableId = 'MDE6QW5zaWJsZVZhcmlhYmxlLTY2';
+const variableId = 66;
+
+const barVariableGlobalId = 'MDE6QW5zaWJsZVZhcmlhYmxlLTU3Mw==';
+const barVariableId = 573;
+
+const withFqdnOverride = canEdit => ({
+  __typename: 'OverridenAnsibleVariable',
+  meta: {
+    __typename: 'Meta',
+    canEdit,
+  },
+  id: ansibleVariableId,
+  key: 'rectangle',
+  defaultValue: 17,
+  parameterType: 'integer',
+  ansibleRoleName: 'test.role',
+  validatorType: '',
+  validatorRule: null,
+  required: false,
+  lookupValues: {
+    nodes: [
+      {
+        __typename: 'LookupValue',
+        id: overrideUpdateDeleteId,
+        match,
+        value: 21,
+        omit: false,
+      },
+    ],
+  },
+  currentValue: {
+    __typename: 'AnsibleVariableOverride',
+    value: 21,
+    element: 'fqdn',
+    elementName: name,
+  },
+});
+
+const withDomainOverride = canEdit => ({
+  __typename: 'OverridenAnsibleVariable',
+  meta: {
+    __typename: 'Meta',
+    canEdit,
+  },
+  id: 'MDE6QW5zaWJsZVZhcmlhYmxlLTc4',
+  key: 'circle',
+  defaultValue: 'd',
+  parameterType: 'string',
+  ansibleRoleName: 'test.role',
+  validatorType: '',
+  validatorRule: null,
+  required: false,
+  lookupValues: {
+    nodes: [],
+  },
+  currentValue: {
+    __typename: 'AnsibleVariableOverride',
+    value: 'c',
+    element: 'domain',
+    elementName: 'example.com',
+  },
+});
+
+export const unauthorizedMocks = [
+  {
+    request: {
+      query: variableOverridesQuery,
+      variables: {
+        id: hostGlobalId,
+        match,
+        first: 20,
+        last: 20,
+      },
+    },
+    result: {
+      data: {
+        currentUser: admin,
+        host: {
+          id: hostGlobalId,
+          ansibleVariablesWithOverrides: {
+            totalCount: 2,
+            nodes: [withFqdnOverride(false), withDomainOverride(false)],
+          },
+        },
+      },
+    },
+  },
+];
+
+export const mocks = [
+  {
+    request: {
+      query: variableOverridesQuery,
+      variables: {
+        id: hostGlobalId,
+        match,
+        first: 20,
+        last: 20,
+      },
+    },
+    result: {
+      data: {
+        currentUser: admin,
+        host: {
+          id: hostGlobalId,
+          ansibleVariablesWithOverrides: {
+            totalCount: 8,
+            nodes: [
+              withFqdnOverride(true),
+              {
+                __typename: 'OverridenAnsibleVariable',
+                meta: {
+                  __typename: 'Meta',
+                  canEdit: true,
+                },
+                id: barVariableGlobalId,
+                key: 'bar',
+                defaultValue: 'a',
+                parameterType: 'string',
+                ansibleRoleName: 'test.role',
+                validatorType: 'list',
+                validatorRule: 'a,b,c',
+                required: true,
+                lookupValues: {
+                  nodes: [
+                    {
+                      __typename: 'LookupValue',
+                      id: 'MDE6TG9va3VwVmFsdWUtODE=',
+                      match,
+                      value: 'b',
+                      omit: false,
+                    },
+                  ],
+                },
+                currentValue: null,
+              },
+              {
+                __typename: 'OverridenAnsibleVariable',
+                meta: {
+                  __typename: 'Meta',
+                  canEdit: true,
+                },
+                id: 'MDE6QW5zaWJsZVZhcmlhYmxlLTY1',
+                key: 'square',
+                defaultValue: true,
+                parameterType: 'boolean',
+                ansibleRoleName: 'test.role',
+                validatorType: '',
+                validatorRule: null,
+                required: false,
+                lookupValues: {
+                  nodes: [],
+                },
+                currentValue: null,
+              },
+              {
+                __typename: 'OverridenAnsibleVariable',
+                meta: {
+                  __typename: 'Meta',
+                  canEdit: true,
+                },
+                id: 'MDE6QW5zaWJsZVZhcmlhYmxlLTc4',
+                key: 'circle',
+                defaultValue: 'd',
+                parameterType: 'string',
+                ansibleRoleName: 'test.role',
+                validatorType: '',
+                validatorRule: null,
+                required: false,
+                lookupValues: {
+                  nodes: [],
+                },
+                currentValue: {
+                  __typename: 'AnsibleVariableOverride',
+                  value: 'c',
+                  element: 'domain',
+                  elementName: 'example.com',
+                },
+              },
+              {
+                __typename: 'OverridenAnsibleVariable',
+                meta: {
+                  __typename: 'Meta',
+                  canEdit: true,
+                },
+                id: 'MDE6QW5zaWJsZVZhcmlhYmxlLTc5',
+                key: 'ellipse',
+                defaultValue: ['seven', 'eight'],
+                parameterType: 'array',
+                ansibleRoleName: 'test.role',
+                validatorType: '',
+                validatorRule: null,
+                required: false,
+                lookupValues: {
+                  nodes: [],
+                },
+                currentValue: {
+                  __typename: 'AnsibleVariableOverride',
+                  value: ['nine'],
+                  element: 'hostgroup',
+                  elementName: 'parent hostgroup',
+                },
+              },
+              {
+                __typename: 'OverridenAnsibleVariable',
+                meta: {
+                  __typename: 'Meta',
+                  canEdit: true,
+                },
+                id: 'MDE6QW5zaWJsZVZhcmlhYmxlLTY2Ng==',
+                key: 'spiral',
+                defaultValue: { one: 'one', two: 'two' },
+                parameterType: 'hash',
+                ansibleRoleName: 'test.role',
+                validatorType: '',
+                validatorRule: null,
+                required: false,
+                lookupValues: {
+                  nodes: [],
+                },
+                currentValue: null,
+              },
+              {
+                __typename: 'OverridenAnsibleVariable',
+                meta: {
+                  __typename: 'Meta',
+                  canEdit: true,
+                },
+                id: 'MDE6QW5zaWJsZVZhcmlhYmxlLTY3Mg==',
+                key: 'sun',
+                defaultValue: "{ one: 'one', two: 'two' }",
+                parameterType: 'json',
+                ansibleRoleName: 'test.role',
+                validatorType: '',
+                validatorRule: null,
+                required: false,
+                lookupValues: {
+                  nodes: [],
+                },
+                currentValue: null,
+              },
+              {
+                __typename: 'OverridenAnsibleVariable',
+                meta: {
+                  __typename: 'Meta',
+                  canEdit: true,
+                },
+                id: 'MDE6QW5zaWJsZVZhcmlhYmxlLTY3Mw==',
+                key: 'moon',
+                defaultValue: [
+                  { hosts: 'all', become: 'true', roles: ['foo'] },
+                ],
+                parameterType: 'yaml',
+                ansibleRoleName: 'test.role',
+                validatorType: '',
+                validatorRule: null,
+                required: false,
+                lookupValues: {
+                  nodes: [],
+                },
+                currentValue: null,
+              },
+            ],
+          },
+        },
+      },
+    },
+  },
+];
+
+export const deleteMocks = [
+  {
+    request: {
+      query: deleteAnsibleVariableOverride,
+      variables: { id: overrideUpdateDeleteId, hostId, variableId },
+    },
+    result: {
+      data: {
+        deleteAnsibleVariableOverride: {
+          errors: [],
+          id: overrideUpdateDeleteId,
+          overridenAnsibleVariable: {
+            __typename: 'OverridenAnsibleVariable',
+            id: ansibleVariableId,
+            currentValue: {
+              __typename: 'AnsibleVariableOverride',
+              element: 'os',
+              elementName: 'CentOS 7.8',
+              value: 101,
+            },
+          },
+        },
+      },
+    },
+  },
+];
+
+const updateMockFactory = (variableValue, returnValue, errors = []) => {
+  const mockArray = [
+    {
+      request: {
+        query: updateAnsibleVariableOverride,
+        variables: {
+          id: overrideUpdateDeleteId,
+          hostId,
+          ansibleVariableId: variableId,
+          value: variableValue,
+          match: `fqdn=${hostAttrs.name}`,
+        },
+      },
+      result: {
+        data: {
+          updateAnsibleVariableOverride: {
+            __typename: 'UpdateAnsibleVariableOverrideMutationPayload',
+            overridenAnsibleVariable: {
+              __typename: 'OverridenAnsibleVariable',
+              id: ansibleVariableId,
+              lookupValues: {
+                __typename: 'LookupValueConnection',
+                nodes: [
+                  {
+                    __typename: 'LookupValue',
+                    id: 'MDE6TG9va3VwVmFsdWUtOTY=',
+                    match: 'fqdn=centos-random.example.com',
+                    value: returnValue,
+                    omit: false,
+                  },
+                ],
+              },
+              currentValue: {
+                __typename: 'AnsibleVariableOverride',
+                element: 'fqdn',
+                elementName: 'centos-random.example.com',
+                value: returnValue,
+              },
+            },
+            errors,
+          },
+        },
+      },
+    },
+  ];
+
+  return mockArray;
+};
+
+const createMockFactory = (variableValue, returnValue, errors = []) => {
+  const variables = {
+    hostId,
+    lookupKeyId: barVariableId,
+    value: variableValue,
+    match: `fqdn=${hostAttrs.name}`,
+  };
+
+  const mockArray = [
+    {
+      request: {
+        query: createAnsibleVariableOverride,
+        variables,
+      },
+      result: {
+        data: {
+          createAnsibleVariableOverride: {
+            overridenAnsibleVariable: {
+              __typename: 'OverridenAnsibleVariable',
+              id: ansibleVariableId,
+              lookupValues: {
+                nodes: [
+                  {
+                    __typename: 'LookupValue',
+                    id: 'MDE6TG9va3VwVmFsdWUtOTY=',
+                    match: 'fqdn=centos-random.example.com',
+                    value: returnValue,
+                    omit: false,
+                  },
+                ],
+              },
+              currentValue: {
+                __typename: 'AnsibleVariableOverride',
+                element: 'fqdn',
+                elementName: 'centos-random.example.com',
+                value: returnValue,
+              },
+            },
+            errors,
+          },
+        },
+      },
+    },
+  ];
+
+  return mockArray;
+};
+
+export const updateMocks = updateMockFactory('2177', 2177);
+export const createMocks = createMockFactory('b', 'b');
+export const updateErrorMocks = updateMockFactory('2177', 21, [
+  {
+    path: ['base'],
+    message: 'Not enough minerals',
+    __typename: 'AttributeError',
+  },
+]);
+
+export const updateValidationMocks = updateMockFactory('foo', 21, [
+  {
+    path: ['attributes', 'value'],
+    message: 'is invalid integer',
+    __typename: 'AttributeError',
+  },
+]);

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

@@ -0,0 +1,71 @@
+import React from 'react';
+import { render, screen, waitFor } from '@testing-library/react';
+import '@testing-library/jest-dom';
+
+import AnsibleVariableOverrides from '../';
+import {
+  mocks,
+  unauthorizedMocks,
+  hostId,
+  hostAttrs,
+} from './AnsibleVariableOverrides.fixtures';
+import {
+  withMockedProvider,
+  withRedux,
+  tick,
+  historyMock,
+} from '../../../../../testHelper';
+
+const TestComponent = withRedux(withMockedProvider(AnsibleVariableOverrides));
+
+describe('AnsibleVariableOverrides', () => {
+  it('should show skeleton when page is loading', () => {
+    const { container } = render(
+      <TestComponent
+        hostId={hostId}
+        hostAttrs={hostAttrs}
+        mocks={mocks}
+        history={historyMock}
+      />
+    );
+    expect(
+      container.getElementsByClassName('react-loading-skeleton')
+    ).toHaveLength(5);
+  });
+  it('should load', async () => {
+    render(
+      <TestComponent
+        hostId={hostId}
+        mocks={mocks}
+        hostAttrs={hostAttrs}
+        history={historyMock}
+      />
+    );
+    await waitFor(tick);
+    expect(screen.getByText('rectangle')).toBeInTheDocument();
+    expect(screen.getByText('square')).toBeInTheDocument();
+    expect(screen.getByText('circle')).toBeInTheDocument();
+    expect(screen.getByText('ellipse')).toBeInTheDocument();
+    expect(screen.getByText('sun')).toBeInTheDocument();
+    expect(screen.getByText('moon')).toBeInTheDocument();
+  });
+  it('should not allow editing when user does not have permissions', async () => {
+    render(
+      <TestComponent
+        hostId={hostId}
+        mocks={unauthorizedMocks}
+        hostAttrs={hostAttrs}
+        history={historyMock}
+      />
+    );
+    await waitFor(tick);
+    expect(screen.getByText('rectangle')).toBeInTheDocument();
+    expect(screen.getByText('circle')).toBeInTheDocument();
+    const editBtns = screen.queryAllByRole('button', {
+      name: 'Edit override button',
+    });
+    expect(editBtns).toHaveLength(0);
+    const actions = screen.queryAllByRole('button', { name: 'Actions' });
+    expect(actions).toHaveLength(0);
+  });
+});