@mui/x-date-pickers 6.1.0 → 6.2.0

package/modern/tests/describeGregorianAdapter/testCalculations.js

@@ -0,0 +1,272 @@
+import { expect } from 'chai';
+export const testCalculations = ({
+  adapter,
+  testDate,
+  testDateISO,
+  formatDateTime
+}) => {
+  it('Method: date', () => {
+    // ISO string
+    expect(adapter.isEqual(testDate, adapter.date(testDateISO))).to.equal(true);
+
+    // Native Date
+    expect(adapter.isEqual(testDate, adapter.date(new Date(testDateISO)))).to.equal(true);
+
+    // Parse already date-specific object
+    expect(adapter.isEqual(testDate, adapter.date(adapter.date(testDateISO)))).to.equal(true);
+
+    // Parse null inputs
+    expect(adapter.date(null)).to.equal(null);
+
+    // Undefined
+    expect(!!adapter.date(undefined)).to.equal(true);
+  });
+  it('Method: isValid', () => {
+    const invalidDate = adapter.date('2018-42-30T11:60:00.000Z');
+    expect(adapter.isValid(testDate)).to.equal(true);
+    expect(adapter.isValid(invalidDate)).to.equal(false);
+    expect(adapter.isValid(undefined)).to.equal(true);
+    expect(adapter.isValid(null)).to.equal(false);
+    expect(adapter.isValid('2018-42-30T11:60:00.000Z')).to.equal(false);
+  });
+  it('Method: addYears', () => {
+    expect(adapter.format(adapter.addYears(testDate, 2), 'year')).to.equal('2020');
+    expect(adapter.format(adapter.addYears(testDate, -2), 'year')).to.equal('2016');
+  });
+  it('Method: addMonths', () => {
+    expect(adapter.format(adapter.addMonths(testDate, 2), 'monthAndYear')).to.equal('December 2018');
+    expect(adapter.format(adapter.addMonths(testDate, -2), 'monthAndYear')).to.equal('August 2018');
+  });
+  it('Method: addWeeks', () => {
+    expect(adapter.getDiff(adapter.addWeeks(testDate, 1), testDate, 'weeks')).to.equal(1);
+    expect(adapter.getDiff(adapter.addWeeks(testDate, -1), testDate, 'weeks')).to.equal(-1);
+  });
+  it('Method: addDays', () => {
+    expect(adapter.format(adapter.addDays(testDate, 1), 'dayOfMonth')).to.equal('31');
+    expect(adapter.format(adapter.addDays(testDate, -1), 'dayOfMonth')).to.equal('29');
+  });
+  it('Method: addHours', () => {
+    expect(adapter.format(adapter.addHours(testDate, 65), 'hours24h')).to.equal('04');
+    expect(adapter.format(adapter.addHours(testDate, -5), 'hours24h')).to.equal('06');
+  });
+  it('Method: addMinutes', () => {
+    expect(adapter.format(adapter.addMinutes(testDate, 65), 'minutes')).to.equal('49');
+    expect(adapter.format(adapter.addMinutes(testDate, -5), 'minutes')).to.equal('39');
+  });
+  it('Method: addSeconds', () => {
+    expect(adapter.format(adapter.addSeconds(testDate, 65), 'seconds')).to.equal('05');
+    expect(adapter.format(adapter.addSeconds(testDate, -5), 'seconds')).to.equal('55');
+  });
+  it('Method: startOfYear', () => {
+    expect(adapter.formatByString(adapter.startOfYear(testDate), formatDateTime)).to.equal('2018-01-01 00:00:00');
+  });
+  it('Method: startOfMonth', () => {
+    expect(adapter.formatByString(adapter.startOfMonth(testDate), formatDateTime)).to.equal('2018-10-01 00:00:00');
+  });
+  it('Method: startOfWeek', () => {
+    expect(adapter.formatByString(adapter.startOfWeek(testDate), formatDateTime)).to.equal(adapter.lib === 'luxon' ? '2018-10-29 00:00:00' : '2018-10-28 00:00:00');
+
+    // Non ISO
+    expect(adapter.formatByString(adapter.startOfWeek(adapter.date('2018-10-28T00:00:00.000Z')), formatDateTime)).to.equal(adapter.lib === 'luxon' ? '2018-10-22 00:00:00' : '2018-10-28 00:00:00');
+  });
+  it('Method: startOfDay', () => {
+    expect(adapter.formatByString(adapter.startOfDay(testDate), formatDateTime)).to.equal('2018-10-30 00:00:00');
+  });
+  it('Method: endOfYear', () => {
+    expect(adapter.formatByString(adapter.endOfYear(testDate), formatDateTime)).to.equal('2018-12-31 23:59:59');
+  });
+  it('Method: endOfMonth', () => {
+    expect(adapter.formatByString(adapter.endOfMonth(testDate), formatDateTime)).to.equal('2018-10-31 23:59:59');
+  });
+  it('Method: endOfWeek', () => {
+    expect(adapter.formatByString(adapter.endOfWeek(testDate), formatDateTime)).to.equal(adapter.lib === 'luxon' ? '2018-11-04 23:59:59' : '2018-11-03 23:59:59');
+
+    // Non ISO
+    expect(adapter.formatByString(adapter.endOfWeek(adapter.date('2018-10-28T00:00:00.000Z')), formatDateTime)).to.equal(adapter.lib === 'luxon' ? '2018-10-28 23:59:59' : '2018-11-03 23:59:59');
+  });
+  it('Method: endOfDay', () => {
+    expect(adapter.formatByString(adapter.endOfDay(testDate), formatDateTime)).to.equal('2018-10-30 23:59:59');
+  });
+  it('Method:getPreviousMonth', () => {
+    expect(adapter.formatByString(adapter.getPreviousMonth(testDate), formatDateTime)).to.equal('2018-09-30 11:44:00');
+  });
+  it('Method:getMonthArray', () => {
+    expect(adapter.getMonthArray(testDate).map(date => adapter.formatByString(date, formatDateTime))).to.deep.equal(['2018-01-01 00:00:00', '2018-02-01 00:00:00', '2018-03-01 00:00:00', '2018-04-01 00:00:00', '2018-05-01 00:00:00', '2018-06-01 00:00:00', '2018-07-01 00:00:00', '2018-08-01 00:00:00', '2018-09-01 00:00:00', '2018-10-01 00:00:00', '2018-11-01 00:00:00', '2018-12-01 00:00:00']);
+  });
+  it('Method:getNextMonth', () => {
+    expect(adapter.formatByString(adapter.getNextMonth(testDate), formatDateTime)).to.equal('2018-11-30 11:44:00');
+  });
+  it('Method:getHours', () => {
+    expect(adapter.getHours(testDate)).to.equal(new Date(testDateISO).getHours());
+  });
+  it('Method:getMinutes', () => {
+    expect(adapter.getMinutes(testDate)).to.equal(44);
+  });
+  it('Method:getSeconds', () => {
+    expect(adapter.getSeconds(testDate)).to.equal(0);
+  });
+  it('Method:getDate', () => {
+    expect(adapter.getDate(testDate)).to.equal(30);
+  });
+  it('Method:getYear', () => {
+    expect(adapter.getYear(testDate)).to.equal(2018);
+  });
+  it('Method:getMonth', () => {
+    expect(adapter.getMonth(testDate)).to.equal(9);
+  });
+  it('Method:getDaysInMonth', () => {
+    expect(adapter.getDaysInMonth(testDate)).to.equal(31);
+  });
+  it('Method:setMonth', () => {
+    const updatedTime = adapter.formatByString(adapter.setMonth(testDate, 4), formatDateTime);
+    expect(updatedTime).to.equal('2018-05-30 11:44:00');
+  });
+  it('Method:setHours', () => {
+    const updatedTime = adapter.formatByString(adapter.setHours(testDate, 0), formatDateTime);
+    expect(updatedTime).to.equal('2018-10-30 00:44:00');
+  });
+  it('Method:setMinutes', () => {
+    const updatedTime = adapter.formatByString(adapter.setMinutes(testDate, 12), formatDateTime);
+    expect(updatedTime).to.equal('2018-10-30 11:12:00');
+  });
+  it('Method:setMinutes', () => {
+    const updatedTime = adapter.formatByString(adapter.setMinutes(testDate, 12), formatDateTime);
+    expect(updatedTime).to.equal('2018-10-30 11:12:00');
+  });
+  it('Method:setYear', () => {
+    const updatedTime = adapter.formatByString(adapter.setYear(testDate, 2011), formatDateTime);
+    expect(updatedTime).to.equal('2011-10-30 11:44:00');
+  });
+  it('Method:setDate', () => {
+    const updatedTime = adapter.formatByString(adapter.setDate(testDate, 15), formatDateTime);
+    expect(updatedTime).to.equal('2018-10-15 11:44:00');
+  });
+  it('Method:setSeconds', () => {
+    const updatedValue = adapter.formatByString(adapter.setSeconds(testDate, 11), formatDateTime);
+    expect(updatedValue).to.equal('2018-10-30 11:44:11');
+  });
+  it('Method:isAfter', () => {
+    expect(adapter.isAfter(adapter.date(), testDate)).to.equal(true);
+    expect(adapter.isAfter(testDate, adapter.date())).to.equal(false);
+  });
+  it('Method:isBefore', () => {
+    expect(adapter.isBefore(testDate, adapter.date())).to.equal(true);
+    expect(adapter.isBefore(adapter.date(), testDate)).to.equal(false);
+  });
+  it('Method:isAfterDay', () => {
+    const nextDay = adapter.addDays(testDate, 1);
+    expect(adapter.isAfterDay(nextDay, testDate)).to.equal(true);
+    expect(adapter.isAfterDay(testDate, nextDay)).to.equal(false);
+  });
+  it('Method:isBeforeDay', () => {
+    const previousDay = adapter.addDays(testDate, -1);
+    expect(adapter.isBeforeDay(testDate, previousDay)).to.equal(false);
+    expect(adapter.isBeforeDay(previousDay, testDate)).to.equal(true);
+  });
+  it('Method:isAfterYear', () => {
+    const nextYear = adapter.setYear(testDate, 2019);
+    expect(adapter.isAfterYear(nextYear, testDate)).to.equal(true);
+    expect(adapter.isAfterYear(testDate, nextYear)).to.equal(false);
+  });
+  it('Method:isBeforeYear', () => {
+    const previousYear = adapter.setYear(testDate, 2017);
+    expect(adapter.isBeforeYear(testDate, previousYear)).to.equal(false);
+    expect(adapter.isBeforeYear(previousYear, testDate)).to.equal(true);
+  });
+  it('Method:getWeekArray', () => {
+    const weekArray = adapter.getWeekArray(testDate);
+    expect(weekArray).to.have.length(5);
+    weekArray.forEach(week => {
+      expect(week).to.have.length(7);
+    });
+  });
+  it('Method:getYearRange', () => {
+    const yearRange = adapter.getYearRange(testDate, adapter.setYear(testDate, 2124));
+    expect(yearRange).to.have.length(107);
+    expect(adapter.getYear(yearRange[yearRange.length - 1])).to.equal(2124);
+    const emptyYearRange = adapter.getYearRange(testDate, adapter.setYear(testDate, adapter.getYear(testDate) - 1));
+    expect(emptyYearRange).to.have.length(0);
+  });
+  it('Method: getDiff', () => {
+    expect(adapter.getDiff(testDate, adapter.date('2018-10-29T11:44:00.000Z'))).to.equal(86400000);
+    expect(adapter.getDiff(testDate, adapter.date('2018-10-31T11:44:00.000Z'))).to.equal(-86400000);
+    expect(adapter.getDiff(testDate, '2018-10-31T11:44:00.000Z')).to.equal(-86400000);
+
+    // With units
+    expect(adapter.getDiff(testDate, adapter.date('2017-09-29T11:44:00.000Z'), 'years')).to.equal(1);
+    expect(adapter.getDiff(testDate, adapter.date('2018-08-29T11:44:00.000Z'), 'months')).to.equal(2);
+    expect(adapter.getDiff(testDate, adapter.date('2018-05-29T11:44:00.000Z'), 'quarters')).to.equal(1);
+    expect(adapter.getDiff(testDate, adapter.date('2018-09-29T11:44:00.000Z'), 'days')).to.equal(31);
+    expect(adapter.getDiff(testDate, adapter.date('2018-09-29T11:44:00.000Z'), 'weeks')).to.equal(4);
+    expect(adapter.getDiff(testDate, adapter.date('2018-09-29T11:44:00.000Z'), 'hours')).to.equal(744);
+    expect(adapter.getDiff(testDate, adapter.date('2018-09-29T11:44:00.000Z'), 'minutes')).to.equal(44640);
+    expect(adapter.getDiff(testDate, adapter.date('2018-10-30T10:44:00.000Z'), 'seconds')).to.equal(3600);
+    expect(adapter.getDiff(testDate, adapter.date('2018-10-30T10:44:00.000Z'), 'milliseconds')).to.equal(3600000);
+  });
+  it('Method: mergeDateAndTime', () => {
+    const mergedDate = adapter.mergeDateAndTime(testDate, adapter.date('2018-01-01T14:15:16.000Z'));
+    expect(adapter.toJsDate(mergedDate).toISOString()).to.equal('2018-10-30T14:15:16.000Z');
+  });
+  it('Method: isEqual', () => {
+    expect(adapter.isEqual(adapter.date(null), null)).to.equal(true);
+    expect(adapter.isEqual(testDate, adapter.date(testDateISO))).to.equal(true);
+    expect(adapter.isEqual(null, adapter.date(testDateISO))).to.equal(false);
+  });
+  it('Method: parseISO', () => {
+    const parsedDate = adapter.parseISO(testDateISO);
+    const outputtedISO = adapter.toISO(parsedDate);
+    if (adapter.lib === 'date-fns') {
+      // date-fns never suppress useless milliseconds in the end
+      expect(outputtedISO).to.equal(testDateISO.replace('.000Z', 'Z'));
+    } else if (adapter.lib === 'luxon') {
+      // luxon does not shorthand +00:00 to Z, which is also valid ISO string
+      expect(outputtedISO).to.equal(testDateISO.replace('Z', '+00:00'));
+    } else {
+      expect(outputtedISO).to.equal(testDateISO);
+    }
+  });
+  it('Method: parse', () => {
+    const parsedDate = adapter.parse('2018-10-30 11:44:00', formatDateTime);
+    expect(adapter.isEqual(parsedDate, testDate)).to.equal(true);
+    expect(adapter.parse('', formatDateTime)).to.equal(null);
+
+    // Invalid input
+    const invalidateParsedDate = adapter.parse('99-99-9999', formatDateTime);
+    expect(adapter.isValid(invalidateParsedDate)).to.equal(false);
+  });
+  it('Method: isNull', () => {
+    expect(adapter.isNull(null)).to.equal(true);
+    expect(adapter.isNull(testDate)).to.equal(false);
+  });
+  it('Method: isSameDay', () => {
+    expect(adapter.isSameDay(testDate, adapter.date('2018-10-30T00:00:00.000Z'))).to.equal(true);
+    expect(adapter.isSameDay(testDate, adapter.date('2019-10-30T00:00:00.000Z'))).to.equal(false);
+  });
+  it('Method: isSameMonth', () => {
+    expect(adapter.isSameMonth(testDate, adapter.date('2018-10-01T00:00:00.000Z'))).to.equal(true);
+    expect(adapter.isSameMonth(testDate, adapter.date('2019-10-01T00:00:00.000Z'))).to.equal(false);
+  });
+  it('Method: isSameYear', () => {
+    expect(adapter.isSameYear(testDate, adapter.date('2018-10-01T00:00:00.000Z'))).to.equal(true);
+    expect(adapter.isSameYear(testDate, adapter.date('2019-10-01T00:00:00.000Z'))).to.equal(false);
+  });
+  it('Method: isSameHour', () => {
+    expect(adapter.isSameHour(testDate, adapter.date(testDateISO))).to.equal(true);
+    expect(adapter.isSameHour(testDate, adapter.addDays(adapter.date(testDateISO), 5))).to.equal(false);
+  });
+  it('Method: getCurrentLocaleCode', () => {
+    // Returns the default location
+    expect(adapter.getCurrentLocaleCode()).to.match(/en/);
+  });
+  it('Method: toJsDate', () => {
+    expect(adapter.toJsDate(testDate)).to.be.instanceOf(Date);
+  });
+  it('Method: isWithinRange', () => {
+    expect(adapter.isWithinRange(adapter.date('2019-10-01T00:00:00.000Z'), [adapter.date('2019-09-01T00:00:00.000Z'), adapter.date('2019-11-01T00:00:00.000Z')])).to.equal(true);
+    expect(adapter.isWithinRange(adapter.date('2019-12-01T00:00:00.000Z'), [adapter.date('2019-09-01T00:00:00.000Z'), adapter.date('2019-11-01T00:00:00.000Z')])).to.equal(false);
+
+    // Should use inclusivity of range
+    expect(adapter.isWithinRange(adapter.date('2019-09-01T00:00:00.000Z'), [adapter.date('2019-09-01T00:00:00.000Z'), adapter.date('2019-12-01T00:00:00.000Z')])).to.equal(true);
+    expect(adapter.isWithinRange(adapter.date('2019-12-01T00:00:00.000Z'), [adapter.date('2019-09-01T00:00:00.000Z'), adapter.date('2019-12-01T00:00:00.000Z')])).to.equal(true);
+  });
+};

package/modern/tests/describeGregorianAdapter/testFormat.js

@@ -0,0 +1,27 @@
+import { expect } from 'chai';
+export const testFormat = ({
+  adapter
+}) => {
+  const expectDate = (format, expected) => {
+    const date = adapter.date('2020-01-01T23:44:00.000Z');
+    const result = adapter.format(date, format);
+    expect(result).to.equal(expected);
+  };
+  it('should correctly format standalone hardcoded formats', () => {
+    expectDate('normalDate', '1 January');
+    expectDate('normalDateWithWeekday', 'Wed, Jan 1');
+    expectDate('shortDate', 'Jan 1');
+    expectDate('year', '2020');
+    expectDate('month', 'January');
+    expectDate('monthAndDate', 'January 1');
+    expectDate('weekday', 'Wednesday');
+    expectDate('weekdayShort', 'Wed');
+    expectDate('dayOfMonth', '1');
+    expectDate('fullTime12h', '11:44 PM');
+    expectDate('fullTime24h', '23:44');
+    expectDate('hours12h', '11');
+    expectDate('hours24h', '23');
+    expectDate('minutes', '44');
+    expectDate('seconds', '00');
+  });
+};

package/modern/tests/describeGregorianAdapter/testLocalization.js

@@ -0,0 +1,16 @@
+import { expect } from 'chai';
+export const testLocalization = ({
+  adapter
+}) => {
+  it('Method: formatNumber', () => {
+    expect(adapter.formatNumber('1')).to.equal('1');
+  });
+  it('Method: getMeridiemText', () => {
+    expect(adapter.getMeridiemText('am')).to.equal('AM');
+    expect(adapter.getMeridiemText('pm')).to.equal('PM');
+  });
+  it('Method: getFormatHelperText', () => {
+    expect(adapter.getFormatHelperText(adapter.formats.keyboardDate)).to.equal('mm/dd/yyyy');
+    expect(adapter.getFormatHelperText(adapter.formats.keyboardDateTime12h)).to.equal('mm/dd/yyyy hh:mm (a|p)m');
+  });
+};

package/modern/tests/describeValidation/describeValidation.js

@@ -6,7 +6,8 @@ import { testDayViewValidation } from './testDayViewValidation';
 import { testMonthViewValidation } from './testMonthViewValidation';
 import { testTextFieldValidation } from './testTextFieldValidation';
 import { testYearViewValidation } from './testYearViewValidation';
-const TEST_SUITES = [testYearViewValidation, testMonthViewValidation, testDayViewValidation, testTextFieldValidation];
+import { testMinutesViewValidation } from './testMinutesViewValidation';
+const TEST_SUITES = [testYearViewValidation, testMonthViewValidation, testDayViewValidation, testMinutesViewValidation, testTextFieldValidation];
 function innerDescribeValidation(ElementToTest, getOptions) {
   const {
     after: runAfterHook = () => {},

package/modern/tests/describeValidation/testMinutesViewValidation.js

@@ -0,0 +1,200 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import { expect } from 'chai';
+import * as React from 'react';
+import { screen } from '@mui/monorepo/test/utils';
+import { adapterToUse } from 'test/utils/pickers-utils';
+import { jsx as _jsx } from "react/jsx-runtime";
+const toMinutesLabel = minutes => `${Number(minutes) < 10 ? `0${minutes}` : minutes} minutes`;
+export const testMinutesViewValidation = (ElementToTest, getOption) => {
+  const {
+    componentFamily,
+    views,
+    render,
+    clock,
+    withDate,
+    withTime,
+    variant
+  } = getOption();
+  if (!views.includes('minutes') || !variant || componentFamily !== 'picker' || variant === 'desktop') {
+    return;
+  }
+  describe('minutes view:', () => {
+    const defaultProps = _extends({
+      onChange: () => {},
+      open: true,
+      view: 'minutes',
+      openTo: 'minutes',
+      reduceAnimations: true
+    }, componentFamily.includes('legacy-') ? {
+      componentsProps: {
+        toolbar: {
+          hidden: true
+        }
+      }
+    } : {
+      slotProps: {
+        toolbar: {
+          hidden: true
+        }
+      }
+    });
+    it('should apply shouldDisableTime', function test() {
+      render( /*#__PURE__*/_jsx(ElementToTest, _extends({}, defaultProps, {
+        value: adapterToUse.date(new Date(2018, 2, 12, 8, 15, 0)),
+        shouldDisableTime: date => adapterToUse.isAfter(date, adapterToUse.date(new Date(2018, 2, 12, 8, 20, 0)))
+      })));
+      expect(screen.getByRole('option', {
+        name: toMinutesLabel('10')
+      })).not.to.have.attribute('aria-disabled');
+      expect(screen.getByRole('option', {
+        name: toMinutesLabel('15')
+      })).not.to.have.attribute('aria-disabled');
+      expect(screen.getByRole('option', {
+        name: toMinutesLabel('20')
+      })).not.to.have.attribute('aria-disabled');
+      expect(screen.getByRole('option', {
+        name: toMinutesLabel('25')
+      })).to.have.attribute('aria-disabled');
+      expect(screen.getByRole('option', {
+        name: toMinutesLabel('30')
+      })).to.have.attribute('aria-disabled');
+      expect(screen.getByRole('option', {
+        name: toMinutesLabel('55')
+      })).to.have.attribute('aria-disabled');
+    });
+    it('should apply disablePast', function test() {
+      let now;
+      function WithFakeTimer(props) {
+        now = adapterToUse.date(new Date());
+        return /*#__PURE__*/_jsx(ElementToTest, _extends({
+          value: now
+        }, props));
+      }
+      const {
+        setProps
+      } = render( /*#__PURE__*/_jsx(WithFakeTimer, _extends({}, defaultProps, {
+        disablePast: true
+      })));
+      const tomorrow = adapterToUse.addDays(now, 1);
+      const currentMinutes = adapterToUse.getMinutes(now);
+      const closestNowMinutesOptionValue = Math.floor(currentMinutes / 5) * 5;
+      const previousMinutesOptionValue = Math.floor(currentMinutes / 5) * 5 - 5;
+      const nextMinutesOptionValue = Math.floor(currentMinutes / 5) * 5 + 5;
+      expect(screen.getByRole('option', {
+        name: toMinutesLabel(previousMinutesOptionValue)
+      })).to.have.attribute('aria-disabled');
+      if (currentMinutes <= closestNowMinutesOptionValue) {
+        expect(screen.getByRole('option', {
+          name: toMinutesLabel(closestNowMinutesOptionValue)
+        })).not.to.have.attribute('aria-disabled');
+      } else {
+        expect(screen.getByRole('option', {
+          name: toMinutesLabel(closestNowMinutesOptionValue)
+        })).to.have.attribute('aria-disabled');
+      }
+      expect(screen.getByRole('option', {
+        name: toMinutesLabel(nextMinutesOptionValue)
+      })).not.to.have.attribute('aria-disabled');
+
+      // following validation is relevant only for DateTimePicker
+      if (!withDate || !withTime) {
+        return;
+      }
+      setProps({
+        value: tomorrow
+      });
+      clock.runToLast();
+      expect(screen.getByRole('option', {
+        name: toMinutesLabel(previousMinutesOptionValue)
+      })).not.to.have.attribute('aria-disabled');
+      expect(screen.getByRole('option', {
+        name: toMinutesLabel(closestNowMinutesOptionValue)
+      })).not.to.have.attribute('aria-disabled');
+    });
+    it('should apply disableFuture', function test() {
+      let now;
+      function WithFakeTimer(props) {
+        now = adapterToUse.date(new Date());
+        return /*#__PURE__*/_jsx(ElementToTest, _extends({
+          value: now
+        }, props));
+      }
+      const {
+        setProps
+      } = render( /*#__PURE__*/_jsx(WithFakeTimer, _extends({}, defaultProps, {
+        disableFuture: true
+      })));
+      const yesterday = adapterToUse.addDays(now, -1);
+      const currentMinutes = adapterToUse.getMinutes(now);
+      const closestNowMinutesOptionValue = Math.floor(currentMinutes / 5) * 5;
+      const previousMinutesOptionValue = Math.floor(currentMinutes / 5) * 5 - 5;
+      const nextMinutesOptionValue = Math.floor(currentMinutes / 5) * 5 + 5;
+      expect(screen.getByRole('option', {
+        name: toMinutesLabel(previousMinutesOptionValue)
+      })).not.to.have.attribute('aria-disabled');
+      if (currentMinutes < closestNowMinutesOptionValue) {
+        expect(screen.getByRole('option', {
+          name: toMinutesLabel(closestNowMinutesOptionValue)
+        })).to.have.attribute('aria-disabled');
+      } else {
+        expect(screen.getByRole('option', {
+          name: toMinutesLabel(closestNowMinutesOptionValue)
+        })).not.to.have.attribute('aria-disabled');
+      }
+      expect(screen.getByRole('option', {
+        name: toMinutesLabel(nextMinutesOptionValue)
+      })).to.have.attribute('aria-disabled');
+
+      // following validation is relevant only for DateTimePicker
+      if (!withDate || !withTime) {
+        return;
+      }
+      setProps({
+        value: yesterday
+      });
+      clock.runToLast();
+      expect(screen.getByRole('option', {
+        name: toMinutesLabel(previousMinutesOptionValue)
+      })).not.to.have.attribute('aria-disabled');
+      expect(screen.getByRole('option', {
+        name: toMinutesLabel(closestNowMinutesOptionValue)
+      })).not.to.have.attribute('aria-disabled');
+    });
+    it('should apply maxTime', function test() {
+      render( /*#__PURE__*/_jsx(ElementToTest, _extends({}, defaultProps, {
+        value: adapterToUse.date(new Date(2019, 5, 15, 11, 15, 0)),
+        maxTime: adapterToUse.date(new Date(2019, 5, 15, 11, 20, 0))
+      })));
+      expect(screen.getByRole('option', {
+        name: toMinutesLabel('10')
+      })).not.to.have.attribute('aria-disabled');
+      expect(screen.getByRole('option', {
+        name: toMinutesLabel('15')
+      })).not.to.have.attribute('aria-disabled');
+      expect(screen.getByRole('option', {
+        name: toMinutesLabel('20')
+      })).not.to.have.attribute('aria-disabled');
+      expect(screen.getByRole('option', {
+        name: toMinutesLabel('25')
+      })).to.have.attribute('aria-disabled');
+    });
+    it('should apply minTime', function test() {
+      render( /*#__PURE__*/_jsx(ElementToTest, _extends({}, defaultProps, {
+        value: adapterToUse.date(new Date(2019, 5, 15, 11, 15, 0)),
+        minTime: adapterToUse.date(new Date(2019, 5, 15, 11, 10, 0))
+      })));
+      expect(screen.getByRole('option', {
+        name: toMinutesLabel('0')
+      })).to.have.attribute('aria-disabled');
+      expect(screen.getByRole('option', {
+        name: toMinutesLabel('5')
+      })).to.have.attribute('aria-disabled');
+      expect(screen.getByRole('option', {
+        name: toMinutesLabel('10')
+      })).not.to.have.attribute('aria-disabled');
+      expect(screen.getByRole('option', {
+        name: toMinutesLabel('15')
+      })).not.to.have.attribute('aria-disabled');
+    });
+  });
+};

package/modern/tests/describeValue/testPickerActionBar.js

@@ -73,7 +73,8 @@ export const testPickerActionBar = (ElementToTest, getOptions) => {
             actionBar: {
               actions: ['clear']
             }
-          }
+          },
+          value: emptyValue
         }));
 
         // Clear the date
@@ -93,7 +94,7 @@ export const testPickerActionBar = (ElementToTest, getOptions) => {
           onAccept: onAccept,
           onClose: onClose,
           open: true,
-          defaultValue: values[0],
+          value: values[0],
           componentsProps: {
             actionBar: {
               actions: ['cancel']
@@ -129,7 +130,7 @@ export const testPickerActionBar = (ElementToTest, getOptions) => {
           onAccept: onAccept,
           onClose: onClose,
           open: true,
-          defaultValue: values[0],
+          value: values[0],
           componentsProps: {
             actionBar: {
               actions: ['cancel']
@@ -175,6 +176,54 @@ export const testPickerActionBar = (ElementToTest, getOptions) => {
         expect(onAccept.callCount).to.equal(1);
         expect(onClose.callCount).to.equal(1);
       });
+      it('should call onChange, onClose and onAccept when validating the default value', () => {
+        const onChange = spy();
+        const onAccept = spy();
+        const onClose = spy();
+        render( /*#__PURE__*/_jsx(ElementToTest, {
+          onChange: onChange,
+          onAccept: onAccept,
+          onClose: onClose,
+          open: true,
+          defaultValue: values[0],
+          componentsProps: {
+            actionBar: {
+              actions: ['accept']
+            }
+          },
+          closeOnSelect: false
+        }));
+
+        // Accept the modifications
+        userEvent.mousePress(screen.getByText(/ok/i));
+        expect(onChange.callCount).to.equal(1);
+        expect(onAccept.callCount).to.equal(1);
+        expect(onClose.callCount).to.equal(1);
+      });
+      it('should call onClose but not onAccept when validating an already validated value', () => {
+        const onChange = spy();
+        const onAccept = spy();
+        const onClose = spy();
+        render( /*#__PURE__*/_jsx(ElementToTest, {
+          onChange: onChange,
+          onAccept: onAccept,
+          onClose: onClose,
+          open: true,
+          value: values[0],
+          componentsProps: {
+            actionBar: {
+              actions: ['accept']
+            }
+          },
+          closeOnSelect: false
+        }));
+
+        // Accept the modifications
+        userEvent.mousePress(screen.getByText(/ok/i));
+        expect(onChange.callCount).to.equal(0);
+        expect(onAccept.callCount).to.equal(0);
+        expect(onClose.callCount).to.equal(1);
+      });
     });
   });
 };

package/modern/tests/describeValue/testPickerOpenCloseLifeCycle.js

@@ -149,7 +149,7 @@ export const testPickerOpenCloseLifeCycle = (ElementToTest, getOptions) => {
         onAccept: onAccept,
         onClose: onClose,
         open: true,
-        defaultValue: values[0],
+        value: values[0],
         closeOnSelect: true
       }));
 
@@ -254,10 +254,10 @@ export const testPickerOpenCloseLifeCycle = (ElementToTest, getOptions) => {
       }
       expect(onClose.callCount).to.equal(1);
     });
-    it('should call onClose when clicking outside of the picker without prior change', () => {
+    it('should call onClose when clicking outside of the picker without prior change', function test() {
       // TODO: Fix this test and enable it on mobile and date-range
       if (pickerParams.variant === 'mobile' || pickerParams.type === 'date-range') {
-        return;
+        this.skip();
       }
       const onChange = spy();
       const onAccept = spy();
@@ -266,7 +266,7 @@ export const testPickerOpenCloseLifeCycle = (ElementToTest, getOptions) => {
         onChange: onChange,
         onAccept: onAccept,
         onClose: onClose,
-        defaultValue: values[0],
+        value: values[0],
         open: true,
         closeOnSelect: false
       }));
@@ -277,10 +277,10 @@ export const testPickerOpenCloseLifeCycle = (ElementToTest, getOptions) => {
       expect(onAccept.callCount).to.equal(0);
       expect(onClose.callCount).to.equal(1);
     });
-    it('should call onClose and onAccept with the live value when clicking outside of the picker', () => {
+    it('should call onClose and onAccept with the live value when clicking outside of the picker', function test() {
       // TODO: Fix this test and enable it on mobile and date-range
       if (pickerParams.variant === 'mobile' || pickerParams.type === 'date-range') {
-        return;
+        this.skip();
       }
       const onChange = spy();
       const onAccept = spy();