foreman_remote_execution 4.6.0 → 5.0.1

data/webpack/JobWizard/__tests__/fixtures.js

@@ -1,13 +1,16 @@
-const jobTemplate = {
+import configureMockStore from 'redux-mock-store';
+import hostsQuery from '../steps/HostsAndInputs/hosts.gql';
+import hostgroupsQuery from '../steps/HostsAndInputs/hostgroups.gql';
+
+export const jobTemplate = {
   id: 178,
-  name: 'Run Command - Ansible Default',
+  name: 'template1',
   template:
     "---\n- hosts: all\n  tasks:\n    - shell:\n        cmd: |\n<%=       indent(10) { input('command') } %>\n      register: out\n    - debug: var=out",
   snippet: false,
   default: true,
   job_category: 'Ansible Commands',
   provider_type: 'Ansible',
-  description_format: 'Run %{command}',
   execution_timeout_interval: 2,
   description: null,
 };
@@ -23,4 +26,186 @@ export const jobTemplateResponse = {
     overridable: true,
     current_user: false,
   },
+  advanced_template_inputs: [
+    {
+      name: 'adv plain hidden',
+      required: true,
+      input_type: 'user',
+      description: 'some Description',
+      advanced: true,
+      value_type: 'plain',
+      resource_type: 'ansible_roles',
+      default: 'Default val',
+      hidden_value: true,
+    },
+    {
+      name: 'adv plain select',
+      required: false,
+      input_type: 'user',
+      options: 'option 1\r\noption 2\r\noption 3\r\noption 4',
+      advanced: true,
+      value_type: 'plain',
+      resource_type: 'ansible_roles',
+      default: '',
+      hidden_value: false,
+    },
+    {
+      name: 'adv resource select',
+      required: false,
+      input_type: 'user',
+      value_type: 'resource',
+      advanced: true,
+      resource_type: 'ForemanTasks::Task',
+      default: '',
+      hidden_value: false,
+    },
+    {
+      name: 'adv search',
+      required: false,
+      options: '',
+      advanced: true,
+      value_type: 'search',
+      resource_type: 'foreman_tasks/tasks',
+      default: '',
+      hidden_value: false,
+      url: 'foreman_tasks/tasks',
+    },
+    {
+      name: 'adv date',
+      required: false,
+      options: '',
+      advanced: true,
+      value_type: 'date',
+      resource_type: 'ansible_roles',
+      default: '',
+      hidden_value: false,
+    },
+  ],
+  template_inputs: [
+    {
+      name: 'plain hidden',
+      required: true,
+      input_type: 'user',
+      description: 'some Description',
+      advanced: false,
+      value_type: 'plain',
+      resource_type: 'ansible_roles',
+      default: 'Default val',
+      hidden_value: true,
+    },
+  ],
+};
+
+export const jobCategories = ['Ansible Commands', 'Puppet', 'Services'];
+
+export const testSetup = (selectors, api) => {
+  jest.spyOn(api, 'get');
+  jest.spyOn(selectors, 'selectJobTemplate');
+  jest.spyOn(selectors, 'selectJobTemplates');
+  jest.spyOn(selectors, 'selectJobCategories');
+  jest.spyOn(selectors, 'selectJobCategoriesStatus');
+  jest.spyOn(selectors, 'selectWithKatello');
+
+  jest.spyOn(selectors, 'selectTemplateInputs');
+  jest.spyOn(selectors, 'selectAdvancedTemplateInputs');
+  selectors.selectWithKatello.mockImplementation(() => true);
+  selectors.selectTemplateInputs.mockImplementation(
+    () => jobTemplateResponse.template_inputs
+  );
+  selectors.selectAdvancedTemplateInputs.mockImplementation(
+    () => jobTemplateResponse.advanced_template_inputs
+  );
+  selectors.selectJobCategories.mockImplementation(() => jobCategories);
+  selectors.selectJobTemplates.mockImplementation(() => [
+    jobTemplate,
+    { ...jobTemplate, id: 2, name: 'template2' },
+  ]);
+  selectors.selectJobTemplate.mockImplementation(() => jobTemplateResponse);
+  const mockStore = configureMockStore([]);
+  const store = mockStore({
+    ForemanTasksTask: {
+      response: {
+        subtotal: 10,
+        results: [
+          { id: '1', name: 'resource1' },
+          { id: '2', name: 'resource2' },
+        ],
+      },
+    },
+    HOST_COLLECTIONS: {
+      response: {
+        subtotal: 3,
+        results: [
+          { id: '74', name: 'host_collection1' },
+          { id: '43', name: 'host_collection2' },
+        ],
+      },
+    },
+  });
+  return store;
 };
+
+export const mockApi = api => {
+  api.get.mockImplementation(({ handleSuccess, ...action }) => {
+    if (action.key === 'JOB_CATEGORIES') {
+      handleSuccess &&
+        handleSuccess({ data: { job_categories: jobCategories } });
+    } else if (action.key === 'JOB_TEMPLATE') {
+      handleSuccess &&
+        handleSuccess({
+          data: jobTemplateResponse,
+        });
+    } else if (action.key === 'JOB_TEMPLATES') {
+      handleSuccess &&
+        handleSuccess({
+          data: { results: [jobTemplate] },
+        });
+    } else if (action.key === 'HOST_IDS') {
+      handleSuccess &&
+        handleSuccess({
+          data: { results: [{ name: 'host1' }, { name: 'host3' }] },
+        });
+    }
+    return { type: 'get', ...action };
+  });
+};
+
+export const gqlMock = [
+  {
+    request: {
+      query: hostsQuery,
+      variables: {
+        search: 'name~"" and organization_id=1 and location_id=2',
+      },
+    },
+    result: {
+      data: {
+        hosts: {
+          totalCount: 3,
+          nodes: [{ name: 'host1' }, { name: 'host2' }, { name: 'host3' }],
+        },
+      },
+    },
+  },
+
+  {
+    request: {
+      query: hostgroupsQuery,
+      variables: {
+        search: 'name~"" and organization_id=1 and location_id=2',
+      },
+    },
+    result: {
+      data: {
+        hostgroups: {
+          totalCount: 3,
+          nodes: [
+            { name: 'host_group1' },
+            { name: 'host_group2' },
+            { name: 'host_group3' },
+          ],
+        },
+      },
+    },
+  },
+];

data/webpack/JobWizard/__tests__/integration.test.js

@@ -1,45 +1,42 @@
 import React from 'react';
 import { Provider } from 'react-redux';
-import configureMockStore from 'redux-mock-store';
 import { mount } from '@theforeman/test';
 import { render, fireEvent, screen, act } from '@testing-library/react';
+import { MockedProvider } from '@apollo/client/testing';
 import * as api from 'foremanReact/redux/API';
 import { JobWizard } from '../JobWizard';
 import * as selectors from '../JobWizardSelectors';
-import { jobTemplates, jobTemplateResponse as jobTemplate } from './fixtures';
+import { WIZARD_TITLES } from '../JobWizardConstants';
+import {
+  testSetup,
+  mockApi,
+  jobCategories,
+  jobTemplateResponse as jobTemplate,
+  gqlMock,
+} from './fixtures';
 
-jest.spyOn(api, 'get');
-jest.spyOn(selectors, 'selectJobTemplate');
-jest.spyOn(selectors, 'selectJobTemplates');
-jest.spyOn(selectors, 'selectJobCategories');
-jest.spyOn(selectors, 'selectJobCategoriesStatus');
+const store = testSetup(selectors, api);
 
-const jobCategories = ['Ansible Commands', 'Puppet', 'Services'];
-
-api.get.mockImplementation(({ handleSuccess, ...action }) => {
-  if (action.key === 'JOB_CATEGORIES') {
-    handleSuccess && handleSuccess({ data: { job_categories: jobCategories } });
-  } else if (action.key === 'JOB_TEMPLATE') {
-    handleSuccess &&
-      handleSuccess({
-        data: jobTemplate,
-      });
-  }
-  return { type: 'get', ...action };
-});
-
-selectors.selectJobTemplate.mockImplementation(() => null);
-selectors.selectJobCategories.mockImplementation(() => jobCategories);
-selectors.selectJobCategoriesStatus.mockImplementation(() => null);
-selectors.selectJobTemplates.mockImplementation(() => jobTemplates);
-
-const mockStore = configureMockStore([]);
-const store = mockStore({});
 describe('Job wizard fill', () => {
   it('should select template', async () => {
+    api.get.mockImplementation(({ handleSuccess, ...action }) => {
+      if (action.key === 'JOB_CATEGORIES') {
+        handleSuccess &&
+          handleSuccess({ data: { job_categories: jobCategories } });
+      } else if (action.key === 'JOB_TEMPLATE') {
+        handleSuccess &&
+          handleSuccess({
+            data: jobTemplate,
+          });
+      }
+      return { type: 'get', ...action };
+    });
+    selectors.selectJobTemplate.mockRestore();
+    jest.spyOn(selectors, 'selectJobTemplate');
+    selectors.selectJobTemplate.mockImplementation(() => ({}));
     const wrapper = mount(
       <Provider store={store}>
-        <JobWizard advancedValues={{}} setAdvancedValues={jest.fn()} />
+        <JobWizard />
       </Provider>
     );
     expect(wrapper.find('.pf-c-wizard__nav-link.pf-m-disabled')).toHaveLength(
@@ -47,100 +44,38 @@ describe('Job wizard fill', () => {
     );
     selectors.selectJobCategoriesStatus.mockImplementation(() => 'RESOLVED');
     expect(store.getActions()).toMatchSnapshot('initial');
-
+    selectors.selectJobTemplate.mockRestore();
+    jest.spyOn(selectors, 'selectJobTemplate');
     selectors.selectJobTemplate.mockImplementation(() => jobTemplate);
     wrapper.find('.pf-c-button.pf-c-select__toggle-button').simulate('click');
     await act(async () => {
-      await wrapper.find('.pf-c-select__menu-item').simulate('click');
-      await wrapper.update();
+      await wrapper
+        .find('.pf-c-select__menu-item')
+        .first()
+        .simulate('click');
     });
     expect(store.getActions().slice(-1)).toMatchSnapshot('select template');
+    wrapper.update();
     expect(wrapper.find('.pf-c-wizard__nav-link.pf-m-disabled')).toHaveLength(
       0
     );
   });
 
-  it('should save data between steps for advanced fields', async () => {
-    const wrapper = mount(
-      <Provider store={store}>
-        <JobWizard advancedValues={{}} setAdvancedValues={jest.fn()} />
-      </Provider>
-    );
-    // setup
-    selectors.selectJobCategoriesStatus.mockImplementation(() => 'RESOLVED');
-    selectors.selectJobTemplate.mockImplementation(() => jobTemplate);
-    wrapper.find('.pf-c-button.pf-c-select__toggle-button').simulate('click');
-    wrapper.find('.pf-c-select__menu-item').simulate('click');
-
-    // test
-    expect(wrapper.find('.pf-c-wizard__nav-link.pf-m-disabled')).toHaveLength(
-      0
-    );
-    wrapper
-      .find('.pf-c-wizard__nav-link')
-      .at(2)
-      .simulate('click'); // Advanced step
-    const effectiveUserInput = () => wrapper.find('input#effective-user');
-    const effectiveUesrValue = 'effective user new value';
-    effectiveUserInput().getDOMNode().value = effectiveUesrValue;
-    await act(async () => {
-      await effectiveUserInput().simulate('change');
-      wrapper.update();
-    });
-
-    expect(effectiveUserInput().prop('value')).toEqual(effectiveUesrValue);
-
-    wrapper
-      .find('.pf-c-wizard__nav-link')
-      .at(1)
-      .simulate('click');
-
-    expect(wrapper.find('.pf-c-wizard__nav-link.pf-m-current').text()).toEqual(
-      'Target Hosts'
-    );
-    wrapper
-      .find('.pf-c-wizard__nav-link')
-      .at(2)
-      .simulate('click'); // Advanced step
-
-    expect(effectiveUserInput().prop('value')).toEqual(effectiveUesrValue);
-  });
-
   it('have all steps', async () => {
     selectors.selectJobCategoriesStatus.mockImplementation(() => null);
-    selectors.selectJobTemplate.mockRestore();
     selectors.selectJobTemplates.mockRestore();
     selectors.selectJobCategories.mockRestore();
-    api.get.mockImplementation(({ handleSuccess, ...action }) => {
-      if (action.key === 'JOB_CATEGORIES') {
-        handleSuccess &&
-          handleSuccess({ data: { job_categories: jobCategories } });
-      } else if (action.key === 'JOB_TEMPLATE') {
-        handleSuccess &&
-          handleSuccess({
-            data: jobTemplate,
-          });
-      } else if (action.key === 'JOB_TEMPLATES') {
-        handleSuccess &&
-          handleSuccess({
-            data: { results: [jobTemplate.job_template] },
-          });
-      }
-      return { type: 'get', ...action };
-    });
+    mockApi(api);
 
     render(
-      <Provider store={store}>
-        <JobWizard />
-      </Provider>
+      <MockedProvider mocks={gqlMock} addTypename={false}>
+        <Provider store={store}>
+          <JobWizard />
+        </Provider>
+      </MockedProvider>
     );
-    const steps = [
-      'Target Hosts',
-      'Advanced Fields',
-      'Schedule',
-      'Review Details',
-      'Category and Template',
-    ];
+    const titles = Object.values(WIZARD_TITLES);
+    const steps = [titles[1], titles[0], ...titles.slice(2)]; // the first title is selected at the beggining
     // eslint-disable-next-line no-unused-vars
     for await (const step of steps) {
       const stepSelector = screen.getByText(step);

data/webpack/JobWizard/__tests__/validation.test.js

@@ -0,0 +1,141 @@
+import React from 'react';
+import { Provider } from 'react-redux';
+import { render, fireEvent, screen, act } from '@testing-library/react';
+import { MockedProvider } from '@apollo/client/testing';
+import '@testing-library/jest-dom';
+import * as api from 'foremanReact/redux/API';
+import { JobWizard } from '../JobWizard';
+import * as selectors from '../JobWizardSelectors';
+import { testSetup, mockApi, jobTemplateResponse, gqlMock } from './fixtures';
+import { WIZARD_TITLES } from '../JobWizardConstants';
+
+const store = testSetup(selectors, api);
+
+mockApi(api);
+const templateInputs = [...jobTemplateResponse.template_inputs];
+const advancedTemplateInputs = [
+  ...jobTemplateResponse.advanced_template_inputs,
+];
+templateInputs[0].default = null;
+advancedTemplateInputs[0].default = null;
+selectors.selectTemplateInputs.mockImplementation(() => templateInputs);
+selectors.selectAdvancedTemplateInputs.mockImplementation(
+  () => advancedTemplateInputs
+);
+
+describe('Job wizard validation', () => {
+  afterAll(() => {
+    selectors.selectTemplateInputs.mockRestore();
+    selectors.selectAdvancedTemplateInputs.mockRestore();
+  });
+  it('requeried', async () => {
+    render(
+      <MockedProvider mocks={gqlMock} addTypename={false}>
+        <Provider store={store}>
+          <JobWizard />
+        </Provider>
+      </MockedProvider>
+    );
+    expect(screen.getByText(WIZARD_TITLES.advanced)).toBeDisabled();
+    expect(screen.getByText(WIZARD_TITLES.schedule)).toBeDisabled();
+    expect(screen.getByText(WIZARD_TITLES.review)).toBeDisabled();
+    await act(async () => {
+      fireEvent.click(screen.getByText(WIZARD_TITLES.hostsAndInputs));
+    });
+    const textField = screen.getByLabelText('plain hidden', {
+      selector: 'textarea',
+    });
+    await act(async () => {
+      await fireEvent.change(textField, {
+        target: { value: 'text' },
+      });
+    });
+    expect(screen.getByText(WIZARD_TITLES.advanced)).toBeEnabled();
+    expect(screen.getByText(WIZARD_TITLES.schedule)).toBeDisabled();
+    expect(screen.getByText(WIZARD_TITLES.review)).toBeDisabled();
+
+    await act(async () => {
+      fireEvent.click(screen.getByText(WIZARD_TITLES.advanced));
+    });
+    const advTextField = screen.getByLabelText('adv plain hidden', {
+      selector: 'textarea',
+    });
+    await act(async () => {
+      await fireEvent.change(advTextField, {
+        target: { value: 'text' },
+      });
+    });
+
+    expect(
+      screen.getByText(WIZARD_TITLES.advanced, { selector: 'button' })
+    ).toBeEnabled();
+    expect(screen.getByText(WIZARD_TITLES.schedule)).toBeEnabled();
+    expect(screen.getByText(WIZARD_TITLES.review)).toBeEnabled();
+  });
+
+  it('advanced number', async () => {
+    render(
+      <MockedProvider mocks={gqlMock} addTypename={false}>
+        <Provider store={store}>
+          <JobWizard />
+        </Provider>
+      </MockedProvider>
+    );
+
+    // setup
+    await act(async () => {
+      fireEvent.click(screen.getByText(WIZARD_TITLES.hostsAndInputs));
+    });
+    await act(async () => {
+      await fireEvent.change(
+        screen.getByLabelText('plain hidden', {
+          selector: 'textarea',
+        }),
+        {
+          target: { value: 'text' },
+        }
+      );
+    });
+
+    await act(async () => {
+      fireEvent.click(screen.getByText(WIZARD_TITLES.advanced));
+    });
+    await act(async () => {
+      await fireEvent.change(
+        screen.getByLabelText('adv plain hidden', {
+          selector: 'textarea',
+        }),
+        {
+          target: { value: 'text' },
+        }
+      );
+    });
+    expect(
+      screen.getByText(WIZARD_TITLES.advanced, { selector: 'button' })
+    ).toBeEnabled();
+    expect(screen.getByText(WIZARD_TITLES.schedule)).toBeEnabled();
+    expect(screen.getByText(WIZARD_TITLES.review)).toBeEnabled();
+
+    // test
+    const timeoutField = screen.getByLabelText('timeout to kill', {
+      selector: 'input',
+    });
+    await act(async () => {
+      await fireEvent.change(timeoutField, {
+        target: { value: 'text' },
+      });
+    });
+
+    expect(screen.getByText(WIZARD_TITLES.schedule)).toBeDisabled();
+    expect(screen.getByText(WIZARD_TITLES.review)).toBeDisabled();
+
+    await act(async () => {
+      await fireEvent.change(timeoutField, {
+        target: { value: 123 },
+      });
+    });
+
+    expect(screen.getByText(WIZARD_TITLES.schedule)).toBeEnabled();
+    expect(screen.getByText(WIZARD_TITLES.review)).toBeEnabled();
+  });
+});

data/webpack/JobWizard/autofill.js

@@ -0,0 +1,38 @@
+import { useEffect } from 'react';
+import { useDispatch, useSelector } from 'react-redux';
+import { get } from 'foremanReact/redux/API';
+import { HOST_IDS } from './JobWizardConstants';
+import { selectRouterSearch } from './JobWizardSelectors';
+import './JobWizard.scss';
+
+export const useAutoFill = ({ setSelectedTargets, setHostsSearchQuery }) => {
+  const fills = useSelector(selectRouterSearch);
+  const dispatch = useDispatch();
+
+  useEffect(() => {
+    if (Object.keys(fills).length) {
+      if (fills['host_ids[]']) {
+        dispatch(
+          get({
+            key: HOST_IDS,
+            url: '/api/hosts',
+            params: { search: `id = ${fills['host_ids[]'].join(' or id = ')}` },
+            handleSuccess: ({ data }) => {
+              setSelectedTargets(currentTargets => ({
+                ...currentTargets,
+                hosts: (data.results || []).map(({ name }) => ({
+                  id: name,
+                  name,
+                })),
+              }));
+            },
+          })
+        );
+      }
+      if (fills.search) {
+        setHostsSearchQuery(fills.search);
+      }
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+};

data/webpack/JobWizard/index.js

@@ -1,4 +1,5 @@
 import React from 'react';
+import PropTypes from 'prop-types';
 import { Title, Divider } from '@patternfly/react-core';
 import { translate as __ } from 'foremanReact/common/I18n';
 import PageLayout from 'foremanReact/routes/common/PageLayout/PageLayout';
@@ -29,4 +30,10 @@ const JobWizardPage = () => {
   );
 };
 
+JobWizardPage.propTypes = {
+  location: PropTypes.shape({
+    search: PropTypes.string,
+  }).isRequired,
+};
+
 export default JobWizardPage;

data/webpack/JobWizard/steps/AdvancedFields/AdvancedFields.js

@@ -1,9 +1,11 @@
 import React from 'react';
 import PropTypes from 'prop-types';
 import { useSelector } from 'react-redux';
-import { Title, Form } from '@patternfly/react-core';
-import { translate as __ } from 'foremanReact/common/I18n';
-import { selectJobTemplate } from '../../JobWizardSelectors';
+import { Form } from '@patternfly/react-core';
+import {
+  selectEffectiveUser,
+  selectAdvancedTemplateInputs,
+} from '../../JobWizardSelectors';
 import {
   EffectiveUserField,
   TimeoutToKillField,
@@ -12,17 +14,32 @@ import {
   EffectiveUserPasswordField,
   ConcurrencyLevelField,
   TimeSpanLevelField,
+  TemplateInputsFields,
+  ExecutionOrderingField,
 } from './Fields';
+import { DescriptionField } from './DescriptionField';
+import { WIZARD_TITLES } from '../../JobWizardConstants';
+import { WizardTitle } from '../form/WizardTitle';
 
-export const AdvancedFields = ({ advancedValues, setAdvancedValues }) => {
-  const jobTemplate = useSelector(selectJobTemplate);
-  const effectiveUser = jobTemplate.effective_user;
+export const AdvancedFields = ({
+  templateValues,
+  advancedValues,
+  setAdvancedValues,
+}) => {
+  const effectiveUser = useSelector(selectEffectiveUser);
+  const advancedTemplateInputs = useSelector(selectAdvancedTemplateInputs);
   return (
     <>
-      <Title headingLevel="h2" className="advanced-fields-title">
-        {__('Advanced Fields')}
-      </Title>
-      <Form>
+      <WizardTitle
+        title={WIZARD_TITLES.advanced}
+        className="advanced-fields-title"
+      />
+      <Form id="advanced-fields-job-template" autoComplete="off">
+        <TemplateInputsFields
+          inputs={advancedTemplateInputs}
+          value={advancedValues.templateValues}
+          setValue={newValue => setAdvancedValues({ templateValues: newValue })}
+        />
         {effectiveUser?.overridable && (
           <EffectiveUserField
             value={advancedValues.effectiveUserValue}
@@ -33,6 +50,11 @@ export const AdvancedFields = ({ advancedValues, setAdvancedValues }) => {
             }
           />
         )}
+        <DescriptionField
+          inputValues={{ ...templateValues, ...advancedValues.templateValues }}
+          value={advancedValues.description}
+          setValue={newValue => setAdvancedValues({ description: newValue })}
+        />
         <TimeoutToKillField
           value={advancedValues.timeoutToKill}
           setValue={newValue =>
@@ -81,6 +103,14 @@ export const AdvancedFields = ({ advancedValues, setAdvancedValues }) => {
             })
           }
         />
+        <ExecutionOrderingField
+          isRandomizedOrdering={advancedValues.isRandomizedOrdering}
+          setValue={newValue =>
+            setAdvancedValues({
+              isRandomizedOrdering: newValue,
+            })
+          }
+        />
       </Form>
     </>
   );
@@ -89,5 +119,6 @@ export const AdvancedFields = ({ advancedValues, setAdvancedValues }) => {
 AdvancedFields.propTypes = {
   advancedValues: PropTypes.object.isRequired,
   setAdvancedValues: PropTypes.func.isRequired,
+  templateValues: PropTypes.object.isRequired,
 };
 export default AdvancedFields;