foreman_remote_execution 4.3.1 → 4.5.2

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

@@ -0,0 +1,144 @@
+import React from 'react';
+import { Provider } from 'react-redux';
+import { mount } from '@theforeman/test';
+import { fireEvent, screen, render, act } from '@testing-library/react';
+import * as api from 'foremanReact/redux/API';
+import { JobWizard } from '../../../JobWizard';
+import * as selectors from '../../../JobWizardSelectors';
+import {
+  jobTemplateResponse as jobTemplate,
+  testSetup,
+  mockApi,
+} from '../../../__tests__/fixtures';
+
+const store = testSetup(selectors, api);
+mockApi(api);
+
+jest.spyOn(selectors, 'selectEffectiveUser');
+jest.spyOn(selectors, 'selectTemplateInputs');
+jest.spyOn(selectors, 'selectAdvancedTemplateInputs');
+
+selectors.selectEffectiveUser.mockImplementation(
+  () => jobTemplate.effective_user
+);
+selectors.selectTemplateInputs.mockImplementation(
+  () => jobTemplate.template_inputs
+);
+
+selectors.selectAdvancedTemplateInputs.mockImplementation(
+  () => jobTemplate.advanced_template_inputs
+);
+describe('AdvancedFields', () => {
+  it('should save data between steps for advanced fields', async () => {
+    const wrapper = mount(
+      <Provider store={store}>
+        <JobWizard advancedValues={{}} setAdvancedValues={jest.fn()} />
+      </Provider>
+    );
+    // setup
+    wrapper.find('.pf-c-button.pf-c-select__toggle-button').simulate('click');
+    wrapper
+      .find('.pf-c-select__menu-item')
+      .first()
+      .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 advancedTemplateInput = () =>
+      wrapper.find('.pf-c-form__group-control textarea');
+    const effectiveUesrValue = 'effective user new value';
+    const advancedTemplateInputValue = 'advanced input new value';
+    effectiveUserInput().getDOMNode().value = effectiveUesrValue;
+
+    effectiveUserInput().simulate('change');
+    wrapper.update();
+    advancedTemplateInput().getDOMNode().value = advancedTemplateInputValue;
+    advancedTemplateInput().simulate('change');
+    expect(effectiveUserInput().prop('value')).toEqual(effectiveUesrValue);
+    expect(advancedTemplateInput().prop('value')).toEqual(
+      advancedTemplateInputValue
+    );
+
+    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);
+    expect(advancedTemplateInput().prop('value')).toEqual(
+      advancedTemplateInputValue
+    );
+  });
+  it('fill template fields', async () => {
+    render(
+      <Provider store={store}>
+        <JobWizard />
+      </Provider>
+    );
+    await act(async () => {
+      fireEvent.click(screen.getByText('Advanced Fields'));
+    });
+    const searchValue = 'search test';
+    const textValue = 'I am a text';
+    const dateValue = '08/07/2021';
+    const textField = screen.getByLabelText('adv plain hidden', {
+      selector: 'textarea',
+    });
+    const selectField = screen.getByText('option 1');
+    const searchField = screen.getByPlaceholderText('Filter...');
+    const dateField = screen.getByLabelText('adv date', {
+      selector: 'input',
+    });
+
+    fireEvent.click(selectField);
+    await act(async () => {
+      await fireEvent.click(screen.getByText('option 2'));
+      fireEvent.click(screen.getAllByText('Advanced Fields')[0]); // to remove focus
+      await fireEvent.change(textField, {
+        target: { value: textValue },
+      });
+
+      await fireEvent.change(searchField, {
+        target: { value: searchValue },
+      });
+      await fireEvent.change(dateField, {
+        target: { value: dateValue },
+      });
+    });
+    expect(
+      screen.getByLabelText('adv plain hidden', {
+        selector: 'textarea',
+      }).value
+    ).toBe(textValue);
+    expect(searchField.value).toBe(searchValue);
+    expect(dateField.value).toBe(dateValue);
+    await act(async () => {
+      fireEvent.click(screen.getByText('Category and Template'));
+    });
+    expect(screen.getAllByText('Category and Template')).toHaveLength(3);
+
+    await act(async () => {
+      fireEvent.click(screen.getByText('Advanced Fields'));
+    });
+    expect(textField.value).toBe(textValue);
+    expect(searchField.value).toBe(searchValue);
+    expect(dateField.value).toBe(dateValue);
+    expect(screen.queryAllByText('option 1')).toHaveLength(0);
+    expect(screen.queryAllByText('option 2')).toHaveLength(1);
+  });
+});

data/webpack/JobWizard/steps/AdvancedFields/__tests__/DescriptionField.test.js

@@ -0,0 +1,23 @@
+import React from 'react';
+import { mount } from '@theforeman/test';
+import { DescriptionField } from '../DescriptionField';
+
+describe('DescriptionField', () => {
+  it('rendring', () => {
+    const component = mount(
+      <DescriptionField
+        inputs={[{ name: 'command' }]}
+        value="Run %{command}"
+        setValue={jest.fn()}
+      />
+    );
+    const preview = component.find('#description-preview').hostNodes();
+    const findLink = () => component.find('.pf-m-link.pf-m-inline');
+    expect(findLink().text()).toEqual('Edit job description template');
+    expect(preview.props().value).toEqual('Run command');
+    findLink().simulate('click');
+    const description = component.find('#description').hostNodes();
+    expect(description.props().value).toEqual('Run %{command}');
+    expect(findLink().text()).toEqual('Preview job description');
+  });
+});

data/webpack/JobWizard/steps/CategoryAndTemplate/CategoryAndTemplate.js

@@ -0,0 +1,109 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { Title, Text, TextVariants, Form, Alert } from '@patternfly/react-core';
+import { translate as __ } from 'foremanReact/common/I18n';
+import { SelectField } from '../form/SelectField';
+import { GroupedSelectField } from '../form/GroupedSelectField';
+
+export const CategoryAndTemplate = ({
+  jobCategories,
+  jobTemplates,
+  setJobTemplate,
+  selectedTemplateID,
+  selectedCategory,
+  setCategory,
+  errors,
+}) => {
+  const templatesGroups = {};
+  jobTemplates.forEach(template => {
+    if (templatesGroups[template.provider_type]?.options)
+      templatesGroups[template.provider_type].options.push({
+        label: template.name,
+        value: template.id,
+      });
+    else
+      templatesGroups[template.provider_type] = {
+        options: [{ label: template.name, value: template.id }],
+        groupLabel: template.provider_type,
+      };
+  });
+
+  const selectedTemplate = jobTemplates.find(
+    template => template.id === selectedTemplateID
+  )?.name;
+
+  const onSelectCategory = newCategory => {
+    setCategory(newCategory);
+    setJobTemplate(null);
+  };
+  const { categoryError, allTemplatesError, templateError } = errors;
+  const isError = !!(categoryError || allTemplatesError || templateError);
+  return (
+    <>
+      <Title headingLevel="h2">{__('Category and Template')}</Title>
+      <Text component={TextVariants.p}>{__('All fields are required.')}</Text>
+      <Form>
+        <SelectField
+          label={__('Job category')}
+          fieldId="job_category"
+          options={jobCategories}
+          setValue={onSelectCategory}
+          value={selectedCategory}
+          placeholderText={categoryError ? __('Error') : ''}
+          isDisabled={!!categoryError}
+        />
+        <GroupedSelectField
+          label={__('Job template')}
+          fieldId="job_template"
+          groups={Object.values(templatesGroups)}
+          setSelected={setJobTemplate}
+          selected={selectedTemplate}
+          isDisabled={!!(categoryError || allTemplatesError)}
+          placeholderText={allTemplatesError ? __('Error') : ''}
+        />
+        {isError && (
+          <Alert variant="danger" title={__('Errors:')}>
+            {categoryError && (
+              <span>
+                {__('Categories list failed with:')} {categoryError}
+              </span>
+            )}
+            {allTemplatesError && (
+              <span>
+                {__('Templates list failed with:')} {allTemplatesError}
+              </span>
+            )}
+            {templateError && (
+              <span>
+                {__('Template failed with:')} {templateError}
+              </span>
+            )}
+          </Alert>
+        )}
+      </Form>
+    </>
+  );
+};
+
+CategoryAndTemplate.propTypes = {
+  jobCategories: PropTypes.array,
+  jobTemplates: PropTypes.array,
+  setJobTemplate: PropTypes.func.isRequired,
+  selectedTemplateID: PropTypes.number,
+  setCategory: PropTypes.func.isRequired,
+  selectedCategory: PropTypes.string,
+  errors: PropTypes.shape({
+    categoryError: PropTypes.string,
+    allTemplatesError: PropTypes.string,
+    templateError: PropTypes.string,
+  }),
+};
+CategoryAndTemplate.defaultProps = {
+  jobCategories: [],
+  jobTemplates: [],
+  selectedTemplateID: null,
+  selectedCategory: null,
+  errors: {},
+};
+
+export default CategoryAndTemplate;

data/webpack/JobWizard/steps/CategoryAndTemplate/CategoryAndTemplate.test.js

@@ -0,0 +1,123 @@
+import React from 'react';
+import { Provider } from 'react-redux';
+import { fireEvent, screen, render, act } from '@testing-library/react';
+import * as api from 'foremanReact/redux/API';
+import { JobWizard } from '../../JobWizard';
+import * as selectors from '../../JobWizardSelectors';
+import { testSetup, mockApi } from '../../__tests__/fixtures';
+
+const store = testSetup(selectors, api);
+mockApi(api);
+jest.spyOn(selectors, 'selectCategoryError');
+jest.spyOn(selectors, 'selectAllTemplatesError');
+jest.spyOn(selectors, 'selectTemplateError');
+
+describe('Category And Template', () => {
+  it('should select ', async () => {
+    selectors.selectCategoryError.mockImplementation(() => null);
+    selectors.selectAllTemplatesError.mockImplementation(() => null);
+    selectors.selectTemplateError.mockImplementation(() => null);
+    render(
+      <Provider store={store}>
+        <JobWizard />
+      </Provider>
+    );
+
+    expect(screen.queryAllByLabelText('Error')).toHaveLength(0);
+    expect(screen.queryAllByLabelText('failed')).toHaveLength(0);
+    // Category
+    fireEvent.click(
+      screen.getByLabelText('Ansible Commands', { selector: 'button' })
+    );
+    await act(async () => {
+      await fireEvent.click(screen.getByText('Puppet'));
+    });
+    fireEvent.click(screen.getAllByText('Category and Template')[0]); // to remove focus
+    expect(
+      screen.queryAllByLabelText('Ansible Commands', { selector: 'button' })
+    ).toHaveLength(0);
+    expect(
+      screen.queryAllByLabelText('Puppet', { selector: 'button' })
+    ).toHaveLength(1);
+
+    // Template
+    fireEvent.click(
+      screen.getByDisplayValue('template1', { selector: 'button' })
+    );
+    await act(async () => {
+      await fireEvent.click(screen.getByText('template2'));
+    });
+    fireEvent.click(screen.getAllByText('Category and Template')[0]); // to remove focus
+    expect(
+      screen.queryAllByDisplayValue('template1', { selector: 'button' })
+    ).toHaveLength(0);
+    expect(
+      screen.queryAllByDisplayValue('template2', { selector: 'button' })
+    ).toHaveLength(1);
+  });
+  it('category error ', async () => {
+    selectors.selectCategoryError.mockImplementation(() => 'category error');
+    selectors.selectAllTemplatesError.mockImplementation(() => null);
+    selectors.selectTemplateError.mockImplementation(() => null);
+    render(
+      <Provider store={store}>
+        <JobWizard />
+      </Provider>
+    );
+
+    expect(
+      screen.queryAllByText('Categories list failed with:', { exact: false })
+    ).toHaveLength(1);
+
+    expect(
+      screen.queryAllByText('Templates list failed with:', { exact: false })
+    ).toHaveLength(0);
+    expect(
+      screen.queryAllByText('Template failed with:', { exact: false })
+    ).toHaveLength(0);
+  });
+  it('templates error ', async () => {
+    selectors.selectCategoryError.mockImplementation(() => null);
+    selectors.selectAllTemplatesError.mockImplementation(
+      () => 'templates error'
+    );
+    selectors.selectTemplateError.mockImplementation(() => null);
+    render(
+      <Provider store={store}>
+        <JobWizard />
+      </Provider>
+    );
+
+    expect(
+      screen.queryAllByText('Categories list failed with:', { exact: false })
+    ).toHaveLength(0);
+
+    expect(
+      screen.queryAllByText('Templates list failed with:', { exact: false })
+    ).toHaveLength(1);
+    expect(
+      screen.queryAllByText('Template failed with:', { exact: false })
+    ).toHaveLength(0);
+  });
+  it('template error ', async () => {
+    selectors.selectCategoryError.mockImplementation(() => null);
+    selectors.selectAllTemplatesError.mockImplementation(() => null);
+    selectors.selectTemplateError.mockImplementation(() => 'template error');
+    render(
+      <Provider store={store}>
+        <JobWizard />
+      </Provider>
+    );
+
+    expect(
+      screen.queryAllByText('Categories list failed with:', { exact: false })
+    ).toHaveLength(0);
+
+    expect(
+      screen.queryAllByText('Templates list failed with:', { exact: false })
+    ).toHaveLength(0);
+    expect(
+      screen.queryAllByText('Template failed with:', { exact: false })
+    ).toHaveLength(1);
+  });
+});

data/webpack/JobWizard/steps/CategoryAndTemplate/index.js

@@ -0,0 +1,94 @@
+import React, { useEffect } from 'react';
+import { useSelector, useDispatch } from 'react-redux';
+import PropTypes from 'prop-types';
+import URI from 'urijs';
+import { get } from 'foremanReact/redux/API';
+import {
+  selectJobCategories,
+  selectJobTemplates,
+  selectJobCategoriesStatus,
+  filterJobTemplates,
+  selectCategoryError,
+  selectAllTemplatesError,
+  selectTemplateError,
+} from '../../JobWizardSelectors';
+import { CategoryAndTemplate } from './CategoryAndTemplate';
+
+import {
+  JOB_TEMPLATES,
+  JOB_CATEGORIES,
+  templatesUrl,
+} from '../../JobWizardConstants';
+
+const ConnectedCategoryAndTemplate = ({
+  jobTemplate,
+  setJobTemplate,
+  category,
+  setCategory,
+}) => {
+  const dispatch = useDispatch();
+
+  const jobCategoriesStatus = useSelector(selectJobCategoriesStatus);
+  useEffect(() => {
+    if (!jobCategoriesStatus) {
+      // Don't reload categories if they are already loaded
+      dispatch(
+        get({
+          key: JOB_CATEGORIES,
+          url: '/ui_job_wizard/categories',
+          handleSuccess: response =>
+            setCategory(response.data.job_categories[0] || ''),
+        })
+      );
+    }
+  }, [jobCategoriesStatus, dispatch, setCategory]);
+
+  const jobCategories = useSelector(selectJobCategories);
+  useEffect(() => {
+    if (category) {
+      const templatesUrlObject = new URI(templatesUrl);
+      dispatch(
+        get({
+          key: JOB_TEMPLATES,
+          url: templatesUrlObject.addSearch({
+            search: `job_category="${category}"`,
+            per_page: 'all',
+          }),
+          handleSuccess: response =>
+            setJobTemplate(
+              Number(filterJobTemplates(response?.data?.results)[0]?.id) || null
+            ),
+        })
+      );
+    }
+  }, [category, dispatch, setJobTemplate]);
+
+  const jobTemplates = useSelector(selectJobTemplates);
+
+  const errors = {
+    categoryError: useSelector(selectCategoryError),
+    allTemplatesError: useSelector(selectAllTemplatesError),
+    templateError: useSelector(selectTemplateError),
+  };
+  return (
+    <CategoryAndTemplate
+      jobTemplates={jobTemplates}
+      jobCategories={jobCategories}
+      setJobTemplate={setJobTemplate}
+      selectedTemplateID={jobTemplate}
+      setCategory={setCategory}
+      selectedCategory={category}
+      errors={errors}
+    />
+  );
+};
+
+ConnectedCategoryAndTemplate.propTypes = {
+  jobTemplate: PropTypes.number,
+  setJobTemplate: PropTypes.func.isRequired,
+  category: PropTypes.string.isRequired,
+  setCategory: PropTypes.func.isRequired,
+};
+ConnectedCategoryAndTemplate.defaultProps = { jobTemplate: null };
+
+export default ConnectedCategoryAndTemplate;