@ohos-ports/flowbite-datepicker 2.0.0-beta.0

package/test/options/pick-levle+view.js

@@ -0,0 +1,357 @@
+describe('options - pick level & view', function () {
+  let clock;
+  let input;
+
+  beforeEach(function () {
+    clock = sinon.useFakeTimers({now: new Date(2020, 1, 14)});
+    input = document.createElement('input');
+    testContainer.appendChild(input);
+  });
+
+  afterEach(function () {
+    testContainer.removeChild(input);
+    clock.restore();
+  });
+
+  describe('pickLevel', function () {
+    it('limits the minimum of available views', function () {
+      const {dp, picker} = createDP(input, {pickLevel: 2});
+      const viewSwitch = getViewSwitch(picker);
+      const cells1 = getCells(picker)[1];
+      dp.show();
+
+      expect(viewSwitch.textContent, 'to be', '2020-2029');
+      expect(cells1.textContent, 'to be', '2020');
+
+      cells1.click();
+
+      expect(viewSwitch.textContent, 'to be', '2020-2029');
+      expect(getCells(picker)[1].textContent, 'to be', '2020');
+
+      dp.destroy();
+    });
+
+    it('changes the selection level to month when 1', function () {
+      input.value = '2/14/2020';
+
+      const {dp, picker} = createDP(input, {pickLevel: 1});
+      const [viewSwitch, nextBtn] = getParts(picker, ['.view-switch', '.next-btn']);
+      let cells = getCells(picker);
+      dp.show();
+
+      expect(dp.dates, 'to equal', [dateValue(2020, 1, 1)]);
+      expect(input.value, 'to be', '02/01/2020');
+      expect(viewSwitch.textContent, 'to be', '2020');
+      expect(filterCells(cells, '.selected'), 'to equal', [cells[1]]);
+      expect(filterCells(cells, '.focused'), 'to equal', [cells[1]]);
+
+      // mouse operation
+      cells[0].click();
+
+      cells = getCells(picker);
+      expect(dp.dates, 'to equal', [dateValue(2020, 0, 1)]);
+      expect(input.value, 'to be', '01/01/2020');
+      expect(viewSwitch.textContent, 'to be', '2020');
+      expect(filterCells(cells, '.selected'), 'to equal', [cells[0]]);
+      expect(filterCells(cells, '.focused'), 'to equal', [cells[0]]);
+
+      nextBtn.click();
+      getCells(picker)[7].click();
+
+      cells = getCells(picker);
+      expect(dp.dates, 'to equal', [dateValue(2021, 7, 1)]);
+      expect(input.value, 'to be', '08/01/2021');
+      expect(viewSwitch.textContent, 'to be', '2021');
+      expect(filterCells(cells, '.selected'), 'to equal', [cells[7]]);
+      expect(filterCells(cells, '.focused'), 'to equal', [cells[7]]);
+
+      // keyboard operation
+      simulant.fire(input, 'keydown', {key: 'ArrowLeft', ctrlKey: true});
+      simulant.fire(input, 'keydown', {key: 'ArrowLeft'});
+      simulant.fire(input, 'keydown', {key: 'Enter'});
+
+      cells = getCells(picker);
+      expect(dp.dates, 'to equal', [dateValue(2020, 6, 1)]);
+      expect(input.value, 'to be', '07/01/2020');
+      expect(viewSwitch.textContent, 'to be', '2020');
+      expect(filterCells(cells, '.selected'), 'to equal', [cells[6]]);
+
+      dp.enterEditMode();
+      input.value = '4/20/2021';
+      simulant.fire(input, 'keydown', {key: 'Enter'});
+
+      cells = getCells(picker);
+      expect(dp.dates, 'to equal', [dateValue(2021, 3, 1)]);
+      expect(input.value, 'to be', '04/01/2021');
+      expect(viewSwitch.textContent, 'to be', '2021');
+      expect(filterCells(cells, '.selected'), 'to equal', [cells[3]]);
+
+      // api call
+      viewSwitch.click();
+
+      dp.setDate('2/14/2022');
+
+      cells = getCells(picker);
+      expect(dp.dates, 'to equal', [dateValue(2022, 1, 1)]);
+      expect(input.value, 'to be', '02/01/2022');
+      expect(viewSwitch.textContent, 'to be', '2022');
+      expect(filterCells(cells, '.selected'), 'to equal', [cells[1]]);
+
+      viewSwitch.click();
+      dp.hide();
+
+      input.value = '3/14/2020';
+      dp.update();
+      dp.show();
+
+      cells = getCells(picker);
+      expect(dp.dates, 'to equal', [dateValue(2020, 2, 1)]);
+      expect(input.value, 'to be', '03/01/2020');
+      expect(viewSwitch.textContent, 'to be', '2020');
+      expect(filterCells(cells, '.selected'), 'to equal', [cells[2]]);
+
+      dp.destroy();
+    });
+
+    it('changes the selection level to year when 2', function () {
+      input.value = '2/14/2020';
+
+      const {dp, picker} = createDP(input, {pickLevel: 2});
+      const [viewSwitch, nextBtn] = getParts(picker, ['.view-switch', '.next-btn']);
+      let cells = getCells(picker);
+      dp.show();
+
+      expect(dp.dates, 'to equal', [dateValue(2020, 0, 1)]);
+      expect(input.value, 'to be', '01/01/2020');
+      expect(viewSwitch.textContent, 'to be', '2020-2029');
+      expect(filterCells(cells, '.selected'), 'to equal', [cells[1]]);
+      expect(filterCells(cells, '.focused'), 'to equal', [cells[1]]);
+
+      // mouse operation
+      cells[2].click();
+
+      cells = getCells(picker);
+      expect(dp.dates, 'to equal', [dateValue(2021, 0, 1)]);
+      expect(input.value, 'to be', '01/01/2021');
+      expect(viewSwitch.textContent, 'to be', '2020-2029');
+      expect(filterCells(cells, '.selected'), 'to equal', [cells[2]]);
+      expect(filterCells(cells, '.focused'), 'to equal', [cells[2]]);
+
+      nextBtn.click();
+      getCells(picker)[7].click();
+
+      cells = getCells(picker);
+      expect(dp.dates, 'to equal', [dateValue(2036, 0, 1)]);
+      expect(input.value, 'to be', '01/01/2036');
+      expect(viewSwitch.textContent, 'to be', '2030-2039');
+      expect(filterCells(cells, '.selected'), 'to equal', [cells[7]]);
+      expect(filterCells(cells, '.focused'), 'to equal', [cells[7]]);
+
+      // keyboard operation
+      simulant.fire(input, 'keydown', {key: 'ArrowLeft', ctrlKey: true});
+      simulant.fire(input, 'keydown', {key: 'ArrowLeft'});
+      simulant.fire(input, 'keydown', {key: 'Enter'});
+
+      cells = getCells(picker);
+      expect(dp.dates, 'to equal', [dateValue(2025, 0, 1)]);
+      expect(input.value, 'to be', '01/01/2025');
+      expect(viewSwitch.textContent, 'to be', '2020-2029');
+      expect(filterCells(cells, '.selected'), 'to equal', [cells[6]]);
+
+      dp.enterEditMode();
+      input.value = '4/20/2021';
+      simulant.fire(input, 'keydown', {key: 'Enter'});
+
+      cells = getCells(picker);
+      expect(dp.dates, 'to equal', [dateValue(2021, 0, 1)]);
+      expect(input.value, 'to be', '01/01/2021');
+      expect(viewSwitch.textContent, 'to be', '2020-2029');
+      expect(filterCells(cells, '.selected'), 'to equal', [cells[2]]);
+
+      // api call
+      viewSwitch.click();
+
+      dp.setDate('2/14/2032');
+
+      cells = getCells(picker);
+      expect(dp.dates, 'to equal', [dateValue(2032, 0, 1)]);
+      expect(input.value, 'to be', '01/01/2032');
+      expect(viewSwitch.textContent, 'to be', '2030-2039');
+      expect(filterCells(cells, '.selected'), 'to equal', [cells[3]]);
+
+      viewSwitch.click();
+      dp.hide();
+
+      input.value = '3/14/2020';
+      dp.update();
+      dp.show();
+
+      cells = getCells(picker);
+      expect(dp.dates, 'to equal', [dateValue(2020, 0, 1)]);
+      expect(input.value, 'to be', '01/01/2020');
+      expect(viewSwitch.textContent, 'to be', '2020-2029');
+      expect(filterCells(cells, '.selected'), 'to equal', [cells[1]]);
+
+      dp.destroy();
+    });
+
+    it('can be updated with setOptions()', function () {
+      const {dp, picker} = createDP(input);
+      const viewSwitch = getViewSwitch(picker);
+      dp.setOptions({pickLevel: 1});
+      dp.show();
+
+      let cells = getCells(picker);
+      expect(viewSwitch.textContent, 'to be', '2020');
+      expect(cells[1].textContent, 'to be', 'Feb');
+
+      cells[1].click();
+
+      cells = getCells(picker);
+      expect(dp.dates, 'to equal', [dateValue(2020, 1, 1)]);
+      expect(input.value, 'to be', '02/01/2020');
+      expect(viewSwitch.textContent, 'to be', '2020');
+      expect(filterCells(cells, '.selected'), 'to equal', [cells[0]]);
+
+      dp.setOptions({pickLevel: 0});
+
+      cells = getCells(picker);
+      expect(viewSwitch.textContent, 'to be', 'February 2020');
+      expect(filterCells(cells, '.selected'), 'to equal', [cells[6]]);
+      expect(filterCells(cells, '.focused'), 'to equal', [cells[6]]);
+
+      viewSwitch.click();
+      getCells(picker)[3].click();
+
+      cells = getCells(picker);
+      expect(viewSwitch.textContent, 'to be', 'April 2020');
+      expect(filterCells(cells, '.selected'), 'to equal', []);
+      expect(filterCells(cells, '.focused'), 'to equal', [cells[3]]);
+
+      dp.destroy();
+    });
+  });
+
+  describe('maxView', function () {
+    it('limits the maximum of available views', function () {
+      const {dp, picker} = createDP(input, {maxView: 1});
+      const viewSwitch = getViewSwitch(picker);
+      dp.show();
+
+      viewSwitch.click();
+      viewSwitch.click();
+
+      expect(viewSwitch.textContent, 'to be', '2020');
+      expect(getCells(picker)[0].textContent, 'to be', 'Jan');
+
+      dp.destroy();
+    });
+
+    it('cannot be smaller than pickLevel', function () {
+      const {dp, picker} = createDP(input, {maxView: 1, pickLevel: 2});
+      const viewSwitch = getViewSwitch(picker);
+      dp.show();
+
+      expect(viewSwitch.textContent, 'to be', '2020-2029');
+      expect(getCells(picker)[1].textContent, 'to be', '2020');
+
+      viewSwitch.click();
+
+      expect(viewSwitch.textContent, 'to be', '2020-2029');
+      expect(getCells(picker)[1].textContent, 'to be', '2020');
+
+      dp.destroy();
+    });
+
+    it('can be updated with setOptions()', function () {
+      const {dp, picker} = createDP(input);
+      const viewSwitch = getViewSwitch(picker);
+      dp.setOptions({maxView: 2});
+      dp.show();
+
+      viewSwitch.click();
+      viewSwitch.click();
+      viewSwitch.click();
+
+      expect(viewSwitch.textContent, 'to be', '2020-2029');
+      expect(getCells(picker)[1].textContent, 'to be', '2020');
+
+      dp.setOptions({maxView: 0});
+      expect(viewSwitch.textContent, 'to be', 'February 2020');
+
+      viewSwitch.click();
+      expect(viewSwitch.textContent, 'to be', 'February 2020');
+
+      dp.destroy();
+    });
+  });
+
+  describe('startView', function () {
+    it('specifies the view desplayed on open', function () {
+      const {dp, picker} = createDP(input, {startView: 3});
+      const viewSwitch = getViewSwitch(picker);
+      dp.show();
+
+      expect(viewSwitch.textContent, 'to be', '2000-2090');
+
+      let cells = getCells(picker);
+      expect(filterCells(cells, '.focused'), 'to equal', [cells[3]]);
+      expect(cells[3].textContent, 'to be', '2020');
+
+      dp.destroy();
+    });
+
+    it('cannot be smaller than pickLevel', function () {
+      const {dp, picker} = createDP(input, {startView: 1, pickLevel: 2});
+      const viewSwitch = getViewSwitch(picker);
+      dp.show();
+
+      expect(viewSwitch.textContent, 'to be', '2020-2029');
+
+      let cells = getCells(picker);
+      expect(filterCells(cells, '.focused'), 'to equal', [cells[1]]);
+      expect(cells[1].textContent, 'to be', '2020');
+
+      dp.destroy();
+    });
+
+    it('cannot be larger than maxView', function () {
+      const {dp, picker} = createDP(input, {startView: 3, maxView: 2});
+      const viewSwitch = getViewSwitch(picker);
+      dp.show();
+
+      expect(viewSwitch.textContent, 'to be', '2020-2029');
+
+      let cells = getCells(picker);
+      expect(filterCells(cells, '.focused'), 'to equal', [cells[1]]);
+      expect(cells[1].textContent, 'to be', '2020');
+
+      dp.destroy();
+    });
+
+    it('can be updated with setOptions()', function () {
+      const {dp, picker} = createDP(input);
+      const viewSwitch = getViewSwitch(picker);
+      dp.setOptions({startView: 2});
+      dp.show();
+
+      expect(viewSwitch.textContent, 'to be', '2020-2029');
+
+      let cells = getCells(picker);
+      expect(filterCells(cells, '.focused'), 'to equal', [cells[1]]);
+      expect(cells[1].textContent, 'to be', '2020');
+
+      dp.hide();
+      dp.setOptions({startView: 0});
+      dp.show();
+
+      expect(viewSwitch.textContent, 'to be', 'February 2020');
+
+      cells = getCells(picker);
+      expect(filterCells(cells, '.focused'), 'to equal', [cells[19]]);
+      expect(cells[19].textContent, 'to be', '14');
+
+      dp.destroy();
+    });
+  });
+});

package/test/test.html

@@ -0,0 +1,94 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <title>Mocha Tests</title>
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <link rel="stylesheet" href="../node_modules/mocha/mocha.css" />
+    <style type="text/css">
+      html * {
+        box-sizing: border-box;
+      }
+    </style>
+    <link rel="stylesheet" href="../dist/css/datepicker.css" />
+  </head>
+  <body>
+    <div id="mocha"></div>
+
+    <div id="test-container"></div>
+
+    <script src="../node_modules/mocha/mocha.js"></script>
+    <script src="../node_modules/unexpected/unexpected.js"></script>
+    <script src="../node_modules/sinon/pkg/sinon.js"></script>
+    <script src="../node_modules/simulant/dist/simulant.umd.js"></script>
+
+    <script class="mocha-init">
+      mocha.setup('bdd');
+      mocha.checkLeaks();
+
+      window.testContainer = document.getElementById('test-container');
+    </script>
+    <script src="./_utils/date.js"></script>
+    <script src="./_utils/dom.js"></script>
+    <script class="setup">
+      /* eslint-disable no-undef, no-unused-vars */
+      var expect = weknowhow.expect;
+      var dateValue = dateUtils.dateValue;
+      var parseHTML = domUtils.parseHTML;
+      var isVisible = domUtils.isVisible;
+      var lastItemOf = arr => arr[arr.length - 1];
+
+      var createDP = (el, options) => {
+        const dp = new Datepicker(el, options);
+        return {dp, picker: document.querySelector('.datepicker')};
+      };
+      var createDRP = (el, options) => {
+        const drp = new DateRangePicker(el, options);
+        const [picker0, picker1] = document.querySelectorAll('.datepicker');
+        return {drp, picker0, picker1};
+      };
+      var getParts = (picker, selectors) => selectors.map(sel => picker.querySelector(sel));
+      var getViewSwitch = picker => picker.querySelector('.view-switch');
+      var getCells = picker => Array.from(picker.querySelectorAll('.datepicker-cell'));
+      var filterCells = (cells, criteria) => {
+        const fn = typeof criteria === 'string' ? el => el.matches(criteria) : criteria;
+        return cells.filter(fn);
+      };
+      var getCellIndices = (cells, criteria) => cells.reduce((indices, cell, idx) => {
+        if (cell.matches(criteria)) {
+          indices.push(idx);
+        }
+        return indices;
+      }, []);
+    </script>
+    <script src="../dist/js/datepicker-full.js"></script>
+    <script src="../dist/js/locales/fr.js"></script>
+    <script src="../dist/js/locales/zh-CN.js"></script>
+    <script src="./Datepicker/Datepicker-object.js"></script>
+    <script src="./Datepicker/api-methods.js"></script>
+    <script src="./mouse-operation.js"></script>
+    <script src="./keyboard-operation/keyboard-operation.js"></script>
+    <script src="./keyboard-operation/arrow-left.js"></script>
+    <script src="./keyboard-operation/arrow-right.js"></script>
+    <script src="./keyboard-operation/arrow-up.js"></script>
+    <script src="./keyboard-operation/arrow-down.js"></script>
+    <script src="./keyboard-operation/edit-mode.js"></script>
+    <script src="./events.js"></script>
+    <script src="./options/options.js"></script>
+    <script src="./options/date-restrictions.js"></script>
+    <script src="./options/buttons.js"></script>
+    <script src="./options/format.js"></script>
+    <script src="./options/multidate.js"></script>
+    <script src="./options/pick-levle+view.js"></script>
+    <script src="./options/orientation.js"></script>
+    <script src="./options/before-show.js"></script>
+    <script src="./inline-mode.js"></script>
+    <script src="./DateRangePicker/DateRangePicker.js"></script>
+    <script src="./DateRangePicker/api-methods.js"></script>
+    <script src="./DateRangePicker/date-selection.js"></script>
+    <script src="./DateRangePicker/options.js"></script>
+    <script class="mocha-exec">
+      mocha.run();
+    </script>
+  </body>
+</html>

package/test/unit/DateRangePicker.js

@@ -0,0 +1,192 @@
+import './_setup.js';
+import DateRangePicker from '../../js/DateRangePicker.js';
+import {parseHTML} from '../../js/lib/dom.js';
+// to spy constructor with sinon, import entire module
+// @see: https://github.com/sinonjs/sinon/issues/1358#issuecomment-391643741
+import * as DP from '../../js/Datepicker.js';
+const Datepicker = DP.default;
+
+describe('DateRangePicker', function () {
+  let elem;
+  let input0;
+  let input1;
+
+  beforeEach(function () {
+    elem = parseHTML('<div><input><input></div>').firstChild;
+    [input0, input1] = elem.children;
+    testContainer.appendChild(elem);
+  });
+
+  afterEach(function () {
+    document.querySelectorAll('.datepicker').forEach((el) => {
+      el.parentElement.removeChild(el);
+    });
+    delete input0.datepicker;
+    delete input1.datepicker;
+    delete elem.rangepicker;
+    testContainer.removeChild(elem);
+  });
+
+  describe('constructor', function () {
+    it('attachs the created instance to the bound element', function () {
+      const drp = new DateRangePicker(elem);
+      expect(elem.rangepicker, 'to be', drp);
+    });
+
+    it('configures the instance with the default values', function () {
+      let drp = new DateRangePicker(elem);
+      expect(drp.allowOneSidedRange, 'to be false');
+    });
+
+    it('creates datepicker for the inputs passing rangepicker and given options expect', function () {
+      const spyDPConstructor = sinon.spy(DP, 'default');
+
+      let drp = new DateRangePicker(elem);
+      expect(spyDPConstructor.args, 'to equal', [
+        [input0, {}, drp],
+        [input1, {}, drp],
+      ]);
+      expect(input0.datepicker, 'to be a', Datepicker);
+      expect(input1.datepicker, 'to be a', Datepicker);
+      expect([input0.datepicker, input1.datepicker], 'to equal', drp.datepickers);
+
+      spyDPConstructor.resetHistory();
+      delete input0.datepicker;
+      delete input1.datepicker;
+      delete elem.rangepicker;
+
+      const fakeOptions = {foo: 123, bar: 456};
+      drp = new DateRangePicker(elem, fakeOptions);
+      expect(spyDPConstructor.args, 'to equal', [
+        [input0, fakeOptions, drp],
+        [input1, fakeOptions, drp],
+      ]);
+
+      spyDPConstructor.restore();
+    });
+
+    it('makes datepickers property read-only/immutable', function () {
+      const drp = new DateRangePicker(elem);
+
+      expect(() => { drp.datepickers = []; }, 'to throw a', TypeError);
+      expect(() => { drp.datepickers[0] = null; }, 'to throw a', TypeError);
+      expect(() => { drp.datepickers[2] = {}; }, 'to throw a', TypeError);
+    });
+
+    it('excludes inputs, allowOneSidedRange and maxNumberOfDates from options to pass Datepicker container', function () {
+      const spyDPConstructor = sinon.spy(DP, 'default');
+      new DateRangePicker(elem, {
+        inputs: [input0, input1],
+        allowOneSidedRange: false,
+        maxNumberOfDates: 2,
+        foo: 123,
+      });
+
+      expect(spyDPConstructor.args[0][1], 'to equal', {foo: 123});
+
+      spyDPConstructor.restore();
+    });
+
+    it('works with arbitrary input elements if they are provided in the inputs option', function () {
+      const outsideEl = document.createElement('div');
+      const drp = new DateRangePicker(outsideEl, {inputs: [input0, input1]});
+
+      expect(outsideEl.rangepicker, 'to be', drp);
+      expect(input0.datepicker.rangepicker, 'to be', drp);
+      expect(input1.datepicker.rangepicker, 'to be', drp);
+      expect([input0.datepicker, input1.datepicker], 'to equal', drp.datepickers);
+    });
+
+    it('append datepicker elements to the container)', function () {
+      new DateRangePicker(elem);
+
+      const dpElems = Array.from(document.body.children).filter(el => el.matches('.datepicker'));
+      expect(dpElems, 'to have length', 2);
+    });
+
+    it('does not add the active class to the picker elements', function () {
+      new DateRangePicker(elem);
+
+      const dpElems = Array.from(document.querySelectorAll('.datepicker'));
+      expect(dpElems.filter(el => el.classList.contains('active')), 'to be empty');
+    });
+
+    it('does nothing but creating an instance if number of inputs < 2', function () {
+      elem.removeChild(input1);
+
+      let drp = new DateRangePicker(elem);
+      expect(elem, 'not to have property', 'rangepicker');
+      expect(drp, 'not to have properties', ['inputs', 'datepickers']);
+      expect(input0, 'not to have property', 'datepicker');
+      expect(document.querySelectorAll('.datepicker').length, 'to be', 0);
+
+      const outsideEl = document.createElement('div');
+      drp = new DateRangePicker(outsideEl, {inputs: [input0]});
+      expect(outsideEl, 'not to have property', 'rangepicker');
+      expect(input0, 'not to have property', 'datepicker');
+      expect(document.querySelectorAll('.datepicker').length, 'to be', 0);
+    });
+  });
+
+  describe('destroy()', function () {
+    let drp;
+    let spyDestroy0;
+    let spyDestroy1;
+
+    beforeEach(function () {
+      drp = new DateRangePicker(elem);
+      spyDestroy0 = sinon.spy(input0.datepicker, 'destroy');
+      spyDestroy1 = sinon.spy(input1.datepicker, 'destroy');
+    });
+
+    afterEach(function () {
+      spyDestroy0.restore();
+      spyDestroy1.restore();
+    });
+
+    it('calls destroy() of each datepickers', function () {
+      drp.destroy();
+      expect(spyDestroy0.called, 'to be true');
+      expect(spyDestroy1.called, 'to be true');
+    });
+
+    it('removes the instance from the bound element', function () {
+      drp.destroy();
+      expect(Object.prototype.hasOwnProperty.call(elem, 'rangepicker'), 'to be false');
+    });
+  });
+
+  describe('dates property', function () {
+    it('contains the array of the inputs\' selected dates', function () {
+      const drp = new DateRangePicker(elem);
+      expect(drp.dates, 'to equal', [undefined, undefined]);
+
+      const date0 = new Date(2020, 3, 20).setHours(0, 0, 0, 0);
+      const date1 = new Date(2020, 3, 22).setHours(0, 0, 0, 0);
+      drp.datepickers[0].dates = [date0];
+      drp.datepickers[1].dates = [date1];
+      expect(drp.dates, 'to equal', [date0, date1]);
+    });
+  });
+
+  describe('setOptions()', function () {
+    it('updates allowOneSidedRange but ignores inputs if they are in the given options', function () {
+      const input2 = document.createElement('input');
+      const drp = new DateRangePicker(elem);
+
+      drp.setOptions({allowOneSidedRange: true, inputs: [input2, input0]});
+      expect(drp.allowOneSidedRange, 'to be true');
+      expect(drp.inputs, 'to equal', [input0, input1]);
+    });
+
+    it('calls each datepicker\'s setOptions() with given options except inputs, allowOneSidedRange and maxNumberOfDates', function () {
+      const drp = new DateRangePicker(elem);
+      const stubDP0SetOptions = sinon.stub(drp.datepickers[0], 'setOptions').callsFake(() => {});
+      const stubDP1SetOptions = sinon.stub(drp.datepickers[1], 'setOptions').callsFake(() => {});
+
+      drp.setOptions({inputs: [], allowOneSidedRange: true, maxNumberOfDates: 2, foo: 123, bar: 456});
+      expect(stubDP0SetOptions.args, 'to equal', [[{foo: 123, bar: 456}]]);
+      expect(stubDP1SetOptions.args, 'to equal', [[{foo: 123, bar: 456}]]);
+    });
+  });
+});