foreman_remote_execution 4.7.0 → 5.0.2

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

@@ -0,0 +1,402 @@
+/* eslint-disable max-lines */
+import React from 'react';
+import { Provider } from 'react-redux';
+import configureMockStore from 'redux-mock-store';
+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 { jobTemplate, jobTemplateResponse } from '../../../__tests__/fixtures';
+
+const lodash = require('lodash');
+
+lodash.debounce = fn => fn;
+jest.spyOn(api, 'get');
+jest.spyOn(selectors, 'selectJobTemplate');
+jest.spyOn(selectors, 'selectJobTemplates');
+jest.spyOn(selectors, 'selectJobCategories');
+
+const jobCategories = ['Ansible Commands', 'Puppet', 'Services'];
+
+selectors.selectJobCategories.mockImplementation(() => jobCategories);
+
+selectors.selectJobTemplates.mockImplementation(() => [
+  jobTemplate,
+  { ...jobTemplate, id: 2, name: 'template2' },
+]);
+selectors.selectJobTemplate.mockImplementation(() => jobTemplateResponse);
+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: [jobTemplateResponse.job_template] },
+      });
+  }
+  return { type: 'get', ...action };
+});
+
+const mockStore = configureMockStore([]);
+const store = mockStore({});
+jest.useFakeTimers();
+
+describe('Schedule', () => {
+  it('should save date time between steps ', async () => {
+    render(
+      <Provider store={store}>
+        <JobWizard />
+      </Provider>
+    );
+    await act(async () => {
+      fireEvent.click(screen.getByText('Schedule'));
+    });
+    const newStartDate = '2020/03/12';
+    const newStartTime = '12:03';
+    const newEndsDate = '2030/03/12';
+    const newEndsTime = '17:34';
+    const startsDateField = screen.getByLabelText('starts at datepicker');
+    const endsDateField = screen.getByLabelText('ends datepicker');
+
+    const startsTimeField = screen.getByLabelText('starts at timepicker');
+    const endsTimeField = screen.getByLabelText('ends timepicker');
+
+    const staticQuery = screen.getByLabelText('Static query');
+    const dynamicQuery = screen.getByLabelText('Dynamic query');
+    const purpose = screen.getByLabelText('purpose');
+    const newPurposeLabel = 'some fun text';
+    expect(staticQuery.checked).toBeTruthy();
+    await act(async () => {
+      await fireEvent.change(startsDateField, {
+        target: { value: newStartDate },
+      });
+      await fireEvent.change(startsTimeField, {
+        target: { value: newStartTime },
+      });
+      await fireEvent.change(purpose, {
+        target: { value: newPurposeLabel },
+      });
+      await fireEvent.change(endsDateField, { target: { value: newEndsDate } });
+      await fireEvent.change(endsTimeField, { target: { value: newEndsTime } });
+
+      await fireEvent.click(dynamicQuery);
+      jest.runAllTimers(); // to handle pf4 date picker popover useTimer
+    });
+    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('Schedule'));
+      jest.runAllTimers();
+    });
+    expect(startsDateField.value).toBe(newStartDate);
+    expect(startsTimeField.value).toBe(newStartTime);
+    expect(endsDateField.value).toBe(newEndsDate);
+    expect(endsTimeField.value).toBe(newEndsTime);
+    expect(dynamicQuery.checked).toBeTruthy();
+    expect(purpose.value).toBe(newPurposeLabel);
+  });
+  it('should remove start date time on execute now', async () => {
+    render(
+      <Provider store={store}>
+        <JobWizard />
+      </Provider>
+    );
+    await act(async () => {
+      fireEvent.click(screen.getByText('Schedule'));
+    });
+    const executeNow = screen.getByLabelText('Execute now');
+    const executeFuture = screen.getByLabelText(
+      'Schedule for future execution'
+    );
+    expect(executeNow.checked).toBeTruthy();
+    const newStartDate = '2020/03/12';
+    const newStartTime = '12:03';
+    const startsDateField = screen.getByLabelText('starts at datepicker');
+    const startsTimeField = screen.getByLabelText('starts at timepicker');
+    await act(async () => {
+      await fireEvent.change(startsDateField, {
+        target: { value: newStartDate },
+      });
+      await fireEvent.change(startsTimeField, {
+        target: { value: newStartTime },
+      });
+      await jest.runOnlyPendingTimers();
+    });
+    expect(startsDateField.value).toBe(newStartDate);
+    expect(startsTimeField.value).toBe(newStartTime);
+    expect(executeFuture.checked).toBeTruthy();
+    await act(async () => {
+      await fireEvent.click(executeNow);
+      jest.runAllTimers();
+    });
+    expect(executeNow.checked).toBeTruthy();
+    expect(startsDateField.value).toBe('');
+    expect(startsTimeField.value).toBe('');
+  });
+
+  it('should disable end date on never ends', async () => {
+    render(
+      <Provider store={store}>
+        <JobWizard />
+      </Provider>
+    );
+    await act(async () => {
+      await fireEvent.click(screen.getByText('Schedule'));
+      jest.runAllTimers();
+    });
+    const neverEnds = screen.getByLabelText('Never ends');
+    expect(neverEnds.checked).toBeFalsy();
+
+    const endsDateField = screen.getByLabelText('ends datepicker');
+    const endsTimeField = screen.getByLabelText('ends timepicker');
+    fireEvent.click(
+      screen.getByLabelText('Does not repeat', { selector: 'button' })
+    );
+    await act(async () => {
+      fireEvent.click(screen.getByText('Cronline'));
+    });
+    expect(endsDateField.disabled).toBeFalsy();
+    expect(endsTimeField.disabled).toBeFalsy();
+    await act(async () => {
+      fireEvent.click(neverEnds);
+    });
+    expect(neverEnds.checked).toBeTruthy();
+    expect(endsDateField.disabled).toBeTruthy();
+    expect(endsTimeField.disabled).toBeTruthy();
+  });
+
+  it('should change between repeat on states', async () => {
+    render(
+      <Provider store={store}>
+        <JobWizard />
+      </Provider>
+    );
+    await act(async () => {
+      fireEvent.click(screen.getByText('Schedule'));
+      jest.runAllTimers(); // to handle pf4 date picker popover useTimer
+    });
+    expect(
+      screen.getByPlaceholderText('Repeat N times').hasAttribute('disabled')
+    ).toBeTruthy();
+    expect(screen.getByText('Review Details').disabled).toBeFalsy();
+    await act(async () => {
+      fireEvent.click(
+        screen.getByLabelText('Does not repeat', { selector: 'button' })
+      );
+    });
+
+    await act(async () => {
+      fireEvent.click(screen.getByText('Cronline'));
+    });
+    expect(screen.getByText('Review Details').disabled).toBeTruthy();
+    const newRepeatTimes = '3';
+    const repeatNTimes = screen.getByPlaceholderText('Repeat N times');
+    expect(repeatNTimes.value).toBe('');
+    await act(async () => {
+      fireEvent.change(repeatNTimes, {
+        target: { value: newRepeatTimes },
+      });
+    });
+    expect(repeatNTimes.value).toBe(newRepeatTimes);
+
+    const newCronline = '1 2';
+    const cronline = screen.getByLabelText('cronline');
+    expect(cronline.value).toBe('');
+    await act(async () => {
+      fireEvent.change(cronline, {
+        target: { value: newCronline },
+      });
+    });
+    expect(cronline.value).toBe(newCronline);
+    expect(screen.getByText('Review Details').disabled).toBeFalsy();
+
+    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('Schedule'));
+      jest.runAllTimers();
+    });
+    expect(screen.queryAllByText('Schedule')).toHaveLength(3);
+    expect(repeatNTimes.value).toBe(newRepeatTimes);
+    expect(cronline.value).toBe(newCronline);
+
+    fireEvent.click(screen.getByText('Cronline'));
+    await act(async () => {
+      fireEvent.click(screen.getByText('Monthly'));
+    });
+
+    expect(screen.getByText('Review Details').disabled).toBeTruthy();
+    const newDays = '1,2,3';
+    const days = screen.getByLabelText('days');
+    expect(days.value).toBe('');
+    await act(async () => {
+      fireEvent.change(days, {
+        target: { value: newDays },
+      });
+      fireEvent.click(repeatNTimes);
+    });
+    expect(days.value).toBe(newDays);
+
+    expect(screen.getByText('Review Details').disabled).toBeTruthy();
+    const newAtMonthly = '13:07';
+    const at = () => screen.getByLabelText('repeat-at');
+    expect(at().value).toBe('');
+    await act(async () => {
+      fireEvent.change(at(), {
+        target: { value: newAtMonthly },
+      });
+    });
+    expect(at().value).toBe(newAtMonthly);
+
+    expect(screen.getByText('Review Details').disabled).toBeFalsy();
+    fireEvent.click(screen.getByText('Monthly'));
+    await act(async () => {
+      fireEvent.click(screen.getByText('Weekly'));
+    });
+
+    expect(screen.getByText('Review Details').disabled).toBeTruthy();
+    const dayTue = screen.getByLabelText('Tue checkbox');
+    const daySat = screen.getByLabelText('Sat checkbox');
+    expect(dayTue.checked).toBe(false);
+    expect(daySat.checked).toBe(false);
+    await act(async () => {
+      fireEvent.click(dayTue);
+      fireEvent.change(dayTue, {
+        target: { checked: true },
+      });
+    });
+    await act(async () => {
+      fireEvent.click(daySat);
+      fireEvent.change(daySat, {
+        target: { checked: true },
+      });
+    });
+    expect(dayTue.checked).toBe(true);
+    expect(daySat.checked).toBe(true);
+    const newAtWeekly = '17:53';
+    expect(at().value).toBe(newAtMonthly);
+    await act(async () => {
+      fireEvent.change(at(), {
+        target: { value: newAtWeekly },
+      });
+    });
+    expect(at().value).toBe(newAtWeekly);
+
+    expect(screen.getByText('Review Details').disabled).toBeFalsy();
+    fireEvent.click(screen.getByText('Weekly'));
+    await act(async () => {
+      fireEvent.click(screen.getByText('Daily'));
+    });
+
+    expect(screen.getByText('Review Details').disabled).toBeFalsy();
+    await act(async () => {
+      fireEvent.change(at(), {
+        target: { value: '' },
+      });
+    });
+    expect(screen.getByText('Review Details').disabled).toBeTruthy();
+    const newAtDaily = '17:07';
+    expect(at().value).toBe('');
+    await act(async () => {
+      fireEvent.change(at(), {
+        target: { value: newAtDaily },
+      });
+    });
+    expect(at().value).toBe(newAtDaily);
+    expect(screen.getByText('Review Details').disabled).toBeFalsy();
+
+    fireEvent.click(screen.getByText('Daily'));
+    await act(async () => {
+      fireEvent.click(screen.getByText('Hourly'));
+    });
+
+    expect(screen.getByText('Review Details').disabled).toBeTruthy();
+    const newMinutes = '6';
+    const atHourly = screen.getByLabelText('repeat-at-minute-typeahead');
+    expect(atHourly.value).toBe('');
+    await act(async () => {
+      fireEvent.click(screen.getByLabelText('select minute toggle'));
+    });
+    await act(async () => {
+      fireEvent.click(screen.getByText(newMinutes));
+    });
+    expect(screen.getByText('Review Details').disabled).toBeFalsy();
+    expect(atHourly.value).toBe(newMinutes);
+  });
+  it('should show invalid error on start date after end', async () => {
+    render(
+      <Provider store={store}>
+        <JobWizard />
+      </Provider>
+    );
+    await act(async () => {
+      await fireEvent.click(screen.getByText('Schedule'));
+      jest.runAllTimers();
+    });
+    const neverEnds = screen.getByLabelText('Never ends');
+    expect(neverEnds.checked).toBeFalsy();
+
+    const startsDateField = screen.getByLabelText('starts at datepicker');
+    const endsDateField = screen.getByLabelText('ends datepicker');
+
+    expect(
+      screen.queryAllByText('End time needs to be after start time')
+    ).toHaveLength(0);
+    expect(screen.getByText('Review Details').disabled).toBeFalsy();
+    await act(async () => {
+      await fireEvent.change(startsDateField, {
+        target: { value: '2020/10/15' },
+      });
+      await fireEvent.change(endsDateField, {
+        target: { value: '2020/10/14' },
+      });
+      await jest.runOnlyPendingTimers();
+    });
+
+    expect(
+      screen.queryAllByText('End time needs to be after start time')
+    ).toHaveLength(1);
+
+    expect(screen.getByText('Review Details').disabled).toBeTruthy();
+  });
+  it('purpose and ends should be disabled when no reaccurence ', async () => {
+    render(
+      <Provider store={store}>
+        <JobWizard />
+      </Provider>
+    );
+    await act(async () => {
+      await fireEvent.click(screen.getByText('Schedule'));
+      jest.runAllTimers();
+    });
+
+    const endsDateField = screen.getByLabelText('ends datepicker');
+    const endsTimeField = screen.getByLabelText('ends timepicker');
+    const purpose = screen.getByLabelText('purpose');
+    expect(endsDateField.disabled).toBeTruthy();
+    expect(endsTimeField.disabled).toBeTruthy();
+    expect(purpose.disabled).toBeTruthy();
+    await act(async () => {
+      fireEvent.click(
+        screen.getByLabelText('Does not repeat', { selector: 'button' })
+      );
+    });
+    await act(async () => {
+      fireEvent.click(screen.getByText('Cronline'));
+    });
+    expect(endsDateField.disabled).toBeFalsy();
+    expect(endsTimeField.disabled).toBeFalsy();
+    expect(purpose.disabled).toBeFalsy();
+  });
+});

data/webpack/JobWizard/steps/Schedule/__tests__/StartEndDates.test.js

@@ -1,22 +1,32 @@
 import React from 'react';
-import { render, fireEvent, screen } from '@testing-library/react';
+import { render, fireEvent, screen, act } from '@testing-library/react';
 import { StartEndDates } from '../StartEndDates';
 
 const setEnds = jest.fn();
+const setIsNeverEnds = jest.fn();
+const setValid = jest.fn();
 const props = {
-  starts: '',
-  setStarts: jest.fn(),
+  startsAt: '',
+  startsBefore: '',
+  setStartsAt: jest.fn(),
+  setStartsBefore: jest.fn(),
   ends: 'some-end-date',
   setEnds,
+  setIsNeverEnds,
+  isNeverEnds: false,
+  validEnd: true,
+  setValidEnd: setValid,
+  isFuture: false,
+  isStartBeforeDisabled: false,
+  isEndDisabled: false,
 };
 
 describe('StartEndDates', () => {
-  it('never ends', () => {
-    render(<StartEndDates {...props} />);
-    const neverEnds = screen.getByLabelText('Never ends', {
-      selector: 'input',
-    });
-    fireEvent.click(neverEnds);
-    expect(setEnds).toBeCalledWith('');
+  it('never ends', async () => {
+    await act(async () => render(<StartEndDates {...props} />));
+    const neverEnds = screen.getByRole('checkbox', { name: 'Never ends' });
+    await act(async () => fireEvent.click(neverEnds));
+    expect(setIsNeverEnds).toBeCalledWith(true);
+    expect(setValid).toBeCalledWith(true);
   });
 });

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

@@ -1,41 +1,178 @@
-import React, { useState } from 'react';
-import { Title, Button, Form } from '@patternfly/react-core';
-import { translate as __ } from 'foremanReact/common/I18n';
+import React, { useEffect, useState } from 'react';
+import PropTypes from 'prop-types';
+import { Form } from '@patternfly/react-core';
 import { ScheduleType } from './ScheduleType';
 import { RepeatOn } from './RepeatOn';
 import { QueryType } from './QueryType';
 import { StartEndDates } from './StartEndDates';
-import { repeatTypes } from '../../JobWizardConstants';
+import { WIZARD_TITLES, repeatTypes } from '../../JobWizardConstants';
+import { PurposeField } from './PurposeField';
+import { WizardTitle } from '../form/WizardTitle';
 
-const Schedule = () => {
-  const [repeatType, setRepeatType] = useState(repeatTypes.noRepeat);
-  const [repeatAmount, setRepeatAmount] = useState('');
-  const [starts, setStarts] = useState('');
-  const [ends, setEnds] = useState('');
+const Schedule = ({ scheduleValue, setScheduleValue, setValid }) => {
+  const {
+    repeatType,
+    repeatAmount,
+    repeatData,
+    startsAt,
+    startsBefore,
+    ends,
+    isNeverEnds,
+    isFuture,
+    isTypeStatic,
+    purpose,
+  } = scheduleValue;
+  const [validEnd, setValidEnd] = useState(true);
+  const [repeatValid, setRepeatValid] = useState(true);
 
+  useEffect(() => {
+    if (!validEnd || !repeatValid) {
+      setValid(false);
+    } else if (isFuture && (startsAt.length || startsBefore.length)) {
+      setValid(true);
+    } else if (!isFuture) {
+      setValid(true);
+    } else {
+      setValid(false);
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [startsAt, startsBefore, isFuture, validEnd, repeatValid]);
   return (
-    <Form className="schedule-tab">
-      <Title headingLevel="h2">{__('Schedule')}</Title>
-      <ScheduleType />
+    <>
+      <WizardTitle title={WIZARD_TITLES.schedule} />
+      <Form className="schedule-tab">
+        <ScheduleType
+          isFuture={isFuture}
+          setIsFuture={newValue => {
+            if (!newValue) {
+              // if schedule type is execute now
+              setScheduleValue(current => ({
+                ...current,
+                startsAt: '',
+                startsBefore: '',
+                isFuture: newValue,
+              }));
+            } else {
+              setScheduleValue(current => ({
+                ...current,
+                startsAt: new Date().toISOString(),
+                isFuture: newValue,
+              }));
+            }
+          }}
+        />
 
-      <RepeatOn
-        repeatType={repeatType}
-        setRepeatType={setRepeatType}
-        repeatAmount={repeatAmount}
-        setRepeatAmount={setRepeatAmount}
-      />
-      <StartEndDates
-        starts={starts}
-        setStarts={setStarts}
-        ends={ends}
-        setEnds={setEnds}
-      />
-      <Button variant="link" className="advanced-scheduling-button" isInline>
-        {__('Advanced scheduling')}
-      </Button>
-      <QueryType />
-    </Form>
+        <RepeatOn
+          repeatType={repeatType}
+          repeatData={repeatData}
+          setRepeatType={newValue => {
+            setScheduleValue(current => ({
+              ...current,
+              repeatType: newValue,
+              startsBefore: '',
+            }));
+          }}
+          setRepeatData={newValue => {
+            setScheduleValue(current => ({
+              ...current,
+              repeatData: newValue,
+            }));
+          }}
+          repeatAmount={repeatAmount}
+          setRepeatAmount={newValue => {
+            setScheduleValue(current => ({
+              ...current,
+              repeatAmount: newValue,
+            }));
+          }}
+          setValid={setRepeatValid}
+        />
+        <StartEndDates
+          startsAt={startsAt}
+          setStartsAt={newValue => {
+            if (!isFuture) {
+              setScheduleValue(current => ({
+                ...current,
+                isFuture: true,
+              }));
+            }
+            setScheduleValue(current => ({
+              ...current,
+              startsAt: newValue,
+            }));
+          }}
+          startsBefore={startsBefore}
+          setStartsBefore={newValue => {
+            if (!isFuture) {
+              setScheduleValue(current => ({
+                ...current,
+                isFuture: true,
+              }));
+            }
+            setScheduleValue(current => ({
+              ...current,
+              startsBefore: newValue,
+            }));
+          }}
+          ends={ends}
+          setEnds={newValue => {
+            setScheduleValue(current => ({
+              ...current,
+              ends: newValue,
+            }));
+          }}
+          isNeverEnds={isNeverEnds}
+          setIsNeverEnds={newValue => {
+            setScheduleValue(current => ({
+              ...current,
+              isNeverEnds: newValue,
+            }));
+          }}
+          validEnd={validEnd}
+          setValidEnd={setValidEnd}
+          isFuture={isFuture}
+          isStartBeforeDisabled={repeatType !== repeatTypes.noRepeat}
+          isEndDisabled={repeatType === repeatTypes.noRepeat}
+        />
+        <QueryType
+          isTypeStatic={isTypeStatic}
+          setIsTypeStatic={newValue => {
+            setScheduleValue(current => ({
+              ...current,
+              isTypeStatic: newValue,
+            }));
+          }}
+        />
+        <PurposeField
+          isDisabled={repeatType === repeatTypes.noRepeat}
+          purpose={purpose}
+          setPurpose={newValue => {
+            setScheduleValue(current => ({
+              ...current,
+              purpose: newValue,
+            }));
+          }}
+        />
+      </Form>
+    </>
   );
 };
 
+Schedule.propTypes = {
+  scheduleValue: PropTypes.shape({
+    repeatType: PropTypes.string.isRequired,
+    repeatAmount: PropTypes.string,
+    repeatData: PropTypes.object,
+    startsAt: PropTypes.string,
+    startsBefore: PropTypes.string,
+    ends: PropTypes.string,
+    isFuture: PropTypes.bool,
+    isNeverEnds: PropTypes.bool,
+    isTypeStatic: PropTypes.bool,
+    purpose: PropTypes.string,
+  }).isRequired,
+  setScheduleValue: PropTypes.func.isRequired,
+  setValid: PropTypes.func.isRequired,
+};
+
 export default Schedule;