foreman_remote_execution 4.8.0 → 5.0.0

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

@@ -1,3 +1,4 @@
+/* eslint-disable max-lines */
 import React from 'react';
 import { Provider } from 'react-redux';
 import configureMockStore from 'redux-mock-store';
@@ -59,12 +60,17 @@ describe('Schedule', () => {
     const newStartTime = '12:03';
     const newEndsDate = '2030/03/12';
     const newEndsTime = '17:34';
-    const [startsDateField, endsDateField] = screen.getAllByPlaceholderText(
-      'yyyy/mm/dd'
-    );
-    const [startsTimeField, endsTimeField] = screen.getAllByPlaceholderText(
-      'hh:mm'
-    );
+    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 },
@@ -72,9 +78,14 @@ describe('Schedule', () => {
       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 } });
-      jest.runAllTimers(); // to handle pf4 date picket popover useTimer
+
+      await fireEvent.click(dynamicQuery);
+      jest.runAllTimers(); // to handle pf4 date picker popover useTimer
     });
     await act(async () => {
       fireEvent.click(screen.getByText('Category and Template'));
@@ -89,6 +100,8 @@ describe('Schedule', () => {
     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(
@@ -106,8 +119,8 @@ describe('Schedule', () => {
     expect(executeNow.checked).toBeTruthy();
     const newStartDate = '2020/03/12';
     const newStartTime = '12:03';
-    const [startsDateField] = screen.getAllByPlaceholderText('yyyy/mm/dd');
-    const [startsTimeField] = screen.getAllByPlaceholderText('hh:mm');
+    const startsDateField = screen.getByLabelText('starts at datepicker');
+    const startsTimeField = screen.getByLabelText('starts at timepicker');
     await act(async () => {
       await fireEvent.change(startsDateField, {
         target: { value: newStartDate },
@@ -122,6 +135,7 @@ describe('Schedule', () => {
     expect(executeFuture.checked).toBeTruthy();
     await act(async () => {
       await fireEvent.click(executeNow);
+      jest.runAllTimers();
     });
     expect(executeNow.checked).toBeTruthy();
     expect(startsDateField.value).toBe('');
@@ -141,8 +155,14 @@ describe('Schedule', () => {
     const neverEnds = screen.getByLabelText('Never ends');
     expect(neverEnds.checked).toBeFalsy();
 
-    const [, endsDateField] = screen.getAllByPlaceholderText('yyyy/mm/dd');
-    const [, endsTimeField] = screen.getAllByPlaceholderText('hh:mm');
+    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 () => {
@@ -152,4 +172,231 @@ describe('Schedule', () => {
     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

@@ -4,13 +4,21 @@ 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', () => {
@@ -19,5 +27,6 @@ describe('StartEndDates', () => {
     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,44 +1,81 @@
-import React from 'react';
+import React, { useEffect, useState } from 'react';
 import PropTypes from 'prop-types';
-import { Button, Form } from '@patternfly/react-core';
-import { translate as __ } from 'foremanReact/common/I18n';
+import { Form } from '@patternfly/react-core';
 import { ScheduleType } from './ScheduleType';
 import { RepeatOn } from './RepeatOn';
 import { QueryType } from './QueryType';
 import { StartEndDates } from './StartEndDates';
-import { WIZARD_TITLES } from '../../JobWizardConstants';
+import { WIZARD_TITLES, repeatTypes } from '../../JobWizardConstants';
+import { PurposeField } from './PurposeField';
 import { WizardTitle } from '../form/WizardTitle';
 
-const Schedule = ({ scheduleValue, setScheduleValue }) => {
-  const { repeatType, repeatAmount, starts, ends, isNeverEnds } = scheduleValue;
+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 (
     <>
       <WizardTitle title={WIZARD_TITLES.schedule} />
       <Form className="schedule-tab">
         <ScheduleType
-          isFuture={scheduleValue.isFuture}
+          isFuture={isFuture}
           setIsFuture={newValue => {
             if (!newValue) {
               // if schedule type is execute now
               setScheduleValue(current => ({
                 ...current,
-                starts: '',
+                startsAt: '',
+                startsBefore: '',
+                isFuture: newValue,
+              }));
+            } else {
+              setScheduleValue(current => ({
+                ...current,
+                startsAt: new Date().toISOString(),
+                isFuture: newValue,
               }));
             }
-            setScheduleValue(current => ({
-              ...current,
-              isFuture: newValue,
-            }));
           }}
         />
 
         <RepeatOn
           repeatType={repeatType}
+          repeatData={repeatData}
           setRepeatType={newValue => {
             setScheduleValue(current => ({
               ...current,
               repeatType: newValue,
+              startsBefore: '',
+            }));
+          }}
+          setRepeatData={newValue => {
+            setScheduleValue(current => ({
+              ...current,
+              repeatData: newValue,
             }));
           }}
           repeatAmount={repeatAmount}
@@ -48,11 +85,12 @@ const Schedule = ({ scheduleValue, setScheduleValue }) => {
               repeatAmount: newValue,
             }));
           }}
+          setValid={setRepeatValid}
         />
         <StartEndDates
-          starts={starts}
-          setStarts={newValue => {
-            if (!scheduleValue.isFuture) {
+          startsAt={startsAt}
+          setStartsAt={newValue => {
+            if (!isFuture) {
               setScheduleValue(current => ({
                 ...current,
                 isFuture: true,
@@ -60,7 +98,20 @@ const Schedule = ({ scheduleValue, setScheduleValue }) => {
             }
             setScheduleValue(current => ({
               ...current,
-              starts: newValue,
+              startsAt: newValue,
+            }));
+          }}
+          startsBefore={startsBefore}
+          setStartsBefore={newValue => {
+            if (!isFuture) {
+              setScheduleValue(current => ({
+                ...current,
+                isFuture: true,
+              }));
+            }
+            setScheduleValue(current => ({
+              ...current,
+              startsBefore: newValue,
             }));
           }}
           ends={ends}
@@ -77,11 +128,31 @@ const Schedule = ({ scheduleValue, setScheduleValue }) => {
               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,
+            }));
+          }}
         />
-        <Button variant="link" className="advanced-scheduling-button" isInline>
-          {__('Advanced scheduling')}
-        </Button>
-        <QueryType />
       </Form>
     </>
   );
@@ -91,12 +162,17 @@ Schedule.propTypes = {
   scheduleValue: PropTypes.shape({
     repeatType: PropTypes.string.isRequired,
     repeatAmount: PropTypes.string,
-    starts: 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;

data/webpack/JobWizard/steps/form/DateTimePicker.js

@@ -1,10 +1,21 @@
-import React from 'react';
+import React, { useState } from 'react';
 import PropTypes from 'prop-types';
-import { DatePicker, TimePicker } from '@patternfly/react-core';
+import {
+  DatePicker,
+  TimePicker,
+  ValidatedOptions,
+} from '@patternfly/react-core';
 import { debounce } from 'lodash';
-import { translate as __ } from 'foremanReact/common/I18n';
+import { translate as __, documentLocale } from 'foremanReact/common/I18n';
 
-export const DateTimePicker = ({ dateTime, setDateTime, isDisabled }) => {
+export const DateTimePicker = ({
+  dateTime,
+  setDateTime,
+  isDisabled,
+  ariaLabel,
+  allowEmpty,
+}) => {
+  const [validated, setValidated] = useState();
   const dateFormat = date =>
     `${date.getFullYear()}/${(date.getMonth() + 1)
       .toString()
@@ -36,23 +47,36 @@ export const DateTimePicker = ({ dateTime, setDateTime, isDisabled }) => {
 
   const onDateChange = newDate => {
     const parsedNewDate = new Date(newDate);
-
-    if (isValidDate(parsedNewDate)) {
+    if (!newDate.length && allowEmpty) {
+      setDateTime('');
+      setValidated(ValidatedOptions.noval);
+    } else if (isValidDate(parsedNewDate)) {
       parsedNewDate.setHours(dateObject.getHours());
       parsedNewDate.setMinutes(dateObject.getMinutes());
       setDateTime(parsedNewDate.toString());
+      setValidated(ValidatedOptions.noval);
+    } else {
+      setValidated(ValidatedOptions.error);
     }
   };
 
   const onTimeChange = newTime => {
-    if (isValidTime(newTime)) {
+    if (!newTime.length && allowEmpty) {
+      const parsedNewTime = new Date(`${formattedDate} 00:00`);
+      setDateTime(parsedNewTime.toString());
+      setValidated(ValidatedOptions.noval);
+    } else if (isValidTime(newTime)) {
       const parsedNewTime = new Date(`${formattedDate} ${newTime}`);
       setDateTime(parsedNewTime.toString());
+      setValidated(ValidatedOptions.noval);
+    } else {
+      setValidated(ValidatedOptions.error);
     }
   };
   return (
     <>
       <DatePicker
+        aria-label={`${ariaLabel} datepicker`}
         value={formattedDate}
         placeholder="yyyy/mm/dd"
         onChange={debounce(onDateChange, 1000, {
@@ -62,9 +86,14 @@ export const DateTimePicker = ({ dateTime, setDateTime, isDisabled }) => {
         dateFormat={dateFormat}
         dateParse={dateParse}
         isDisabled={isDisabled}
-        invalidFormatText={__('Invalid date')}
+        locale={documentLocale()}
+        invalidFormatText={
+          validated === ValidatedOptions.error ? __('Invalid date') : ''
+        }
+        inputProps={{ validated }}
       />
       <TimePicker
+        aria-label={`${ariaLabel} timepicker`}
         className="time-picker"
         time={dateTime ? dateObject.toString() : ''}
         inputProps={dateTime ? {} : { value: '' }}
@@ -86,8 +115,12 @@ DateTimePicker.propTypes = {
   dateTime: PropTypes.string,
   setDateTime: PropTypes.func.isRequired,
   isDisabled: PropTypes.bool,
+  ariaLabel: PropTypes.string,
+  allowEmpty: PropTypes.bool,
 };
 DateTimePicker.defaultProps = {
   dateTime: null,
   isDisabled: false,
+  ariaLabel: '',
+  allowEmpty: true,
 };

data/webpack/JobWizard/steps/form/FormHelpers.js

@@ -18,3 +18,7 @@ export const helpLabel = (text, id) => {
     </Popover>
   );
 };
+
+export const isPositiveNumber = text => parseInt(text, 10) > 0;
+
+export const isValidDate = d => d instanceof Date && !Number.isNaN(d);