@mui/x-date-pickers 6.1.0 → 6.2.0

package/legacy/tests/describeGregorianAdapter/testCalculations.js

@@ -0,0 +1,273 @@
+import { expect } from 'chai';
+export var testCalculations = function testCalculations(_ref) {
+  var adapter = _ref.adapter,
+    testDate = _ref.testDate,
+    testDateISO = _ref.testDateISO,
+    formatDateTime = _ref.formatDateTime;
+  it('Method: date', function () {
+    // 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', function () {
+    var 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', function () {
+    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', function () {
+    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', function () {
+    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', function () {
+    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', function () {
+    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', function () {
+    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', function () {
+    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', function () {
+    expect(adapter.formatByString(adapter.startOfYear(testDate), formatDateTime)).to.equal('2018-01-01 00:00:00');
+  });
+  it('Method: startOfMonth', function () {
+    expect(adapter.formatByString(adapter.startOfMonth(testDate), formatDateTime)).to.equal('2018-10-01 00:00:00');
+  });
+  it('Method: startOfWeek', function () {
+    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', function () {
+    expect(adapter.formatByString(adapter.startOfDay(testDate), formatDateTime)).to.equal('2018-10-30 00:00:00');
+  });
+  it('Method: endOfYear', function () {
+    expect(adapter.formatByString(adapter.endOfYear(testDate), formatDateTime)).to.equal('2018-12-31 23:59:59');
+  });
+  it('Method: endOfMonth', function () {
+    expect(adapter.formatByString(adapter.endOfMonth(testDate), formatDateTime)).to.equal('2018-10-31 23:59:59');
+  });
+  it('Method: endOfWeek', function () {
+    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', function () {
+    expect(adapter.formatByString(adapter.endOfDay(testDate), formatDateTime)).to.equal('2018-10-30 23:59:59');
+  });
+  it('Method:getPreviousMonth', function () {
+    expect(adapter.formatByString(adapter.getPreviousMonth(testDate), formatDateTime)).to.equal('2018-09-30 11:44:00');
+  });
+  it('Method:getMonthArray', function () {
+    expect(adapter.getMonthArray(testDate).map(function (date) {
+      return 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', function () {
+    expect(adapter.formatByString(adapter.getNextMonth(testDate), formatDateTime)).to.equal('2018-11-30 11:44:00');
+  });
+  it('Method:getHours', function () {
+    expect(adapter.getHours(testDate)).to.equal(new Date(testDateISO).getHours());
+  });
+  it('Method:getMinutes', function () {
+    expect(adapter.getMinutes(testDate)).to.equal(44);
+  });
+  it('Method:getSeconds', function () {
+    expect(adapter.getSeconds(testDate)).to.equal(0);
+  });
+  it('Method:getDate', function () {
+    expect(adapter.getDate(testDate)).to.equal(30);
+  });
+  it('Method:getYear', function () {
+    expect(adapter.getYear(testDate)).to.equal(2018);
+  });
+  it('Method:getMonth', function () {
+    expect(adapter.getMonth(testDate)).to.equal(9);
+  });
+  it('Method:getDaysInMonth', function () {
+    expect(adapter.getDaysInMonth(testDate)).to.equal(31);
+  });
+  it('Method:setMonth', function () {
+    var updatedTime = adapter.formatByString(adapter.setMonth(testDate, 4), formatDateTime);
+    expect(updatedTime).to.equal('2018-05-30 11:44:00');
+  });
+  it('Method:setHours', function () {
+    var updatedTime = adapter.formatByString(adapter.setHours(testDate, 0), formatDateTime);
+    expect(updatedTime).to.equal('2018-10-30 00:44:00');
+  });
+  it('Method:setMinutes', function () {
+    var updatedTime = adapter.formatByString(adapter.setMinutes(testDate, 12), formatDateTime);
+    expect(updatedTime).to.equal('2018-10-30 11:12:00');
+  });
+  it('Method:setMinutes', function () {
+    var updatedTime = adapter.formatByString(adapter.setMinutes(testDate, 12), formatDateTime);
+    expect(updatedTime).to.equal('2018-10-30 11:12:00');
+  });
+  it('Method:setYear', function () {
+    var updatedTime = adapter.formatByString(adapter.setYear(testDate, 2011), formatDateTime);
+    expect(updatedTime).to.equal('2011-10-30 11:44:00');
+  });
+  it('Method:setDate', function () {
+    var updatedTime = adapter.formatByString(adapter.setDate(testDate, 15), formatDateTime);
+    expect(updatedTime).to.equal('2018-10-15 11:44:00');
+  });
+  it('Method:setSeconds', function () {
+    var updatedValue = adapter.formatByString(adapter.setSeconds(testDate, 11), formatDateTime);
+    expect(updatedValue).to.equal('2018-10-30 11:44:11');
+  });
+  it('Method:isAfter', function () {
+    expect(adapter.isAfter(adapter.date(), testDate)).to.equal(true);
+    expect(adapter.isAfter(testDate, adapter.date())).to.equal(false);
+  });
+  it('Method:isBefore', function () {
+    expect(adapter.isBefore(testDate, adapter.date())).to.equal(true);
+    expect(adapter.isBefore(adapter.date(), testDate)).to.equal(false);
+  });
+  it('Method:isAfterDay', function () {
+    var nextDay = adapter.addDays(testDate, 1);
+    expect(adapter.isAfterDay(nextDay, testDate)).to.equal(true);
+    expect(adapter.isAfterDay(testDate, nextDay)).to.equal(false);
+  });
+  it('Method:isBeforeDay', function () {
+    var previousDay = adapter.addDays(testDate, -1);
+    expect(adapter.isBeforeDay(testDate, previousDay)).to.equal(false);
+    expect(adapter.isBeforeDay(previousDay, testDate)).to.equal(true);
+  });
+  it('Method:isAfterYear', function () {
+    var nextYear = adapter.setYear(testDate, 2019);
+    expect(adapter.isAfterYear(nextYear, testDate)).to.equal(true);
+    expect(adapter.isAfterYear(testDate, nextYear)).to.equal(false);
+  });
+  it('Method:isBeforeYear', function () {
+    var previousYear = adapter.setYear(testDate, 2017);
+    expect(adapter.isBeforeYear(testDate, previousYear)).to.equal(false);
+    expect(adapter.isBeforeYear(previousYear, testDate)).to.equal(true);
+  });
+  it('Method:getWeekArray', function () {
+    var weekArray = adapter.getWeekArray(testDate);
+    expect(weekArray).to.have.length(5);
+    weekArray.forEach(function (week) {
+      expect(week).to.have.length(7);
+    });
+  });
+  it('Method:getYearRange', function () {
+    var yearRange = adapter.getYearRange(testDate, adapter.setYear(testDate, 2124));
+    expect(yearRange).to.have.length(107);
+    expect(adapter.getYear(yearRange[yearRange.length - 1])).to.equal(2124);
+    var emptyYearRange = adapter.getYearRange(testDate, adapter.setYear(testDate, adapter.getYear(testDate) - 1));
+    expect(emptyYearRange).to.have.length(0);
+  });
+  it('Method: getDiff', function () {
+    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', function () {
+    var 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', function () {
+    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', function () {
+    var parsedDate = adapter.parseISO(testDateISO);
+    var 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', function () {
+    var 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
+    var invalidateParsedDate = adapter.parse('99-99-9999', formatDateTime);
+    expect(adapter.isValid(invalidateParsedDate)).to.equal(false);
+  });
+  it('Method: isNull', function () {
+    expect(adapter.isNull(null)).to.equal(true);
+    expect(adapter.isNull(testDate)).to.equal(false);
+  });
+  it('Method: isSameDay', function () {
+    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', function () {
+    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', function () {
+    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', function () {
+    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', function () {
+    // Returns the default location
+    expect(adapter.getCurrentLocaleCode()).to.match(/en/);
+  });
+  it('Method: toJsDate', function () {
+    expect(adapter.toJsDate(testDate)).to.be.instanceOf(Date);
+  });
+  it('Method: isWithinRange', function () {
+    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/legacy/tests/describeGregorianAdapter/testFormat.js

@@ -0,0 +1,26 @@
+import { expect } from 'chai';
+export var testFormat = function testFormat(_ref) {
+  var adapter = _ref.adapter;
+  var expectDate = function expectDate(format, expected) {
+    var date = adapter.date('2020-01-01T23:44:00.000Z');
+    var result = adapter.format(date, format);
+    expect(result).to.equal(expected);
+  };
+  it('should correctly format standalone hardcoded formats', function () {
+    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/legacy/tests/describeGregorianAdapter/testLocalization.js

@@ -0,0 +1,15 @@
+import { expect } from 'chai';
+export var testLocalization = function testLocalization(_ref) {
+  var adapter = _ref.adapter;
+  it('Method: formatNumber', function () {
+    expect(adapter.formatNumber('1')).to.equal('1');
+  });
+  it('Method: getMeridiemText', function () {
+    expect(adapter.getMeridiemText('am')).to.equal('AM');
+    expect(adapter.getMeridiemText('pm')).to.equal('PM');
+  });
+  it('Method: getFormatHelperText', function () {
+    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/legacy/tests/describeValidation/describeValidation.js

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

package/legacy/tests/describeValidation/testMinutesViewValidation.js

@@ -0,0 +1,201 @@
+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";
+var toMinutesLabel = function toMinutesLabel(minutes) {
+  return "".concat(Number(minutes) < 10 ? "0".concat(minutes) : minutes, " minutes");
+};
+export var testMinutesViewValidation = function testMinutesViewValidation(ElementToTest, getOption) {
+  var _getOption = getOption(),
+    componentFamily = _getOption.componentFamily,
+    views = _getOption.views,
+    render = _getOption.render,
+    clock = _getOption.clock,
+    withDate = _getOption.withDate,
+    withTime = _getOption.withTime,
+    variant = _getOption.variant;
+  if (!views.includes('minutes') || !variant || componentFamily !== 'picker' || variant === 'desktop') {
+    return;
+  }
+  describe('minutes view:', function () {
+    var defaultProps = _extends({
+      onChange: function 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: function shouldDisableTime(date) {
+          return 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() {
+      var now;
+      function WithFakeTimer(props) {
+        now = adapterToUse.date(new Date());
+        return /*#__PURE__*/_jsx(ElementToTest, _extends({
+          value: now
+        }, props));
+      }
+      var _render = render( /*#__PURE__*/_jsx(WithFakeTimer, _extends({}, defaultProps, {
+          disablePast: true
+        }))),
+        setProps = _render.setProps;
+      var tomorrow = adapterToUse.addDays(now, 1);
+      var currentMinutes = adapterToUse.getMinutes(now);
+      var closestNowMinutesOptionValue = Math.floor(currentMinutes / 5) * 5;
+      var previousMinutesOptionValue = Math.floor(currentMinutes / 5) * 5 - 5;
+      var 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() {
+      var now;
+      function WithFakeTimer(props) {
+        now = adapterToUse.date(new Date());
+        return /*#__PURE__*/_jsx(ElementToTest, _extends({
+          value: now
+        }, props));
+      }
+      var _render2 = render( /*#__PURE__*/_jsx(WithFakeTimer, _extends({}, defaultProps, {
+          disableFuture: true
+        }))),
+        setProps = _render2.setProps;
+      var yesterday = adapterToUse.addDays(now, -1);
+      var currentMinutes = adapterToUse.getMinutes(now);
+      var closestNowMinutesOptionValue = Math.floor(currentMinutes / 5) * 5;
+      var previousMinutesOptionValue = Math.floor(currentMinutes / 5) * 5 - 5;
+      var 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/legacy/tests/describeValue/testPickerActionBar.js

@@ -72,7 +72,8 @@ export var testPickerActionBar = function testPickerActionBar(ElementToTest, get
             actionBar: {
               actions: ['clear']
             }
-          }
+          },
+          value: emptyValue
         }));
 
         // Clear the date
@@ -92,7 +93,7 @@ export var testPickerActionBar = function testPickerActionBar(ElementToTest, get
           onAccept: onAccept,
           onClose: onClose,
           open: true,
-          defaultValue: values[0],
+          value: values[0],
           componentsProps: {
             actionBar: {
               actions: ['cancel']
@@ -128,7 +129,7 @@ export var testPickerActionBar = function testPickerActionBar(ElementToTest, get
           onAccept: onAccept,
           onClose: onClose,
           open: true,
-          defaultValue: values[0],
+          value: values[0],
           componentsProps: {
             actionBar: {
               actions: ['cancel']
@@ -174,6 +175,54 @@ export var testPickerActionBar = function testPickerActionBar(ElementToTest, get
         expect(onAccept.callCount).to.equal(1);
         expect(onClose.callCount).to.equal(1);
       });
+      it('should call onChange, onClose and onAccept when validating the default value', function () {
+        var onChange = spy();
+        var onAccept = spy();
+        var 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', function () {
+        var onChange = spy();
+        var onAccept = spy();
+        var 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/legacy/tests/describeValue/testPickerOpenCloseLifeCycle.js

@@ -147,7 +147,7 @@ export var testPickerOpenCloseLifeCycle = function testPickerOpenCloseLifeCycle(
         onAccept: onAccept,
         onClose: onClose,
         open: true,
-        defaultValue: values[0],
+        value: values[0],
         closeOnSelect: true
       }));
 
@@ -252,10 +252,10 @@ export var testPickerOpenCloseLifeCycle = function testPickerOpenCloseLifeCycle(
       }
       expect(onClose.callCount).to.equal(1);
     });
-    it('should call onClose when clicking outside of the picker without prior change', function () {
+    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();
       }
       var onChange = spy();
       var onAccept = spy();
@@ -264,7 +264,7 @@ export var testPickerOpenCloseLifeCycle = function testPickerOpenCloseLifeCycle(
         onChange: onChange,
         onAccept: onAccept,
         onClose: onClose,
-        defaultValue: values[0],
+        value: values[0],
         open: true,
         closeOnSelect: false
       }));
@@ -275,10 +275,10 @@ export var testPickerOpenCloseLifeCycle = function testPickerOpenCloseLifeCycle(
       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', function () {
+    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();
       }
       var onChange = spy();
       var onAccept = spy();