diff --git a/app/shared/overnight-calendar/OvernightSummary.js b/app/shared/overnight-calendar/OvernightSummary.js
index be412a3ba..fadf438a2 100644
--- a/app/shared/overnight-calendar/OvernightSummary.js
+++ b/app/shared/overnight-calendar/OvernightSummary.js
@@ -36,7 +36,6 @@ function OvernightSummary({
       <div>
         <Button
           bsStyle="primary"
-          className="reservation-calendar__reserve-button2"
           disabled={isDurationBelowMin || !validRange}
           onClick={handleSelectDatetimes}
         >
diff --git a/app/shared/overnight-calendar/overnightUtils.js b/app/shared/overnight-calendar/overnightUtils.js
index 534bf8299..7242c7ded 100644
--- a/app/shared/overnight-calendar/overnightUtils.js
+++ b/app/shared/overnight-calendar/overnightUtils.js
@@ -37,7 +37,7 @@ export function handleDateSelect({
 /**
  * Handles disabling days.
  * @param {Object} params
- * @param {moment} params.day
+ * @param {Date} params.day
  * @param {moment} params.now
  * @param {boolean} params.reservable
  * @param {string} params.reservableAfter datetime
@@ -338,8 +338,11 @@ export function getOvernightDatetime(date, time) {
  * @returns {Object} hours, minutes and seconds
  */
 export function getHoursMinutesSeconds(time) {
-  const [hours, minutes, seconds] = time.split(':').map(Number);
-  return { hours, minutes, seconds };
+  if (time) {
+    const [hours, minutes, seconds] = time.split(':').map(Number);
+    return { hours, minutes, seconds };
+  }
+  return { hours: 0, minutes: 0, seconds: 0 };
 }
 
 /**
diff --git a/app/shared/overnight-calendar/tests/OvernightCalendar.spec.js b/app/shared/overnight-calendar/tests/OvernightCalendar.spec.js
new file mode 100644
index 000000000..8df02987e
--- /dev/null
+++ b/app/shared/overnight-calendar/tests/OvernightCalendar.spec.js
@@ -0,0 +1,143 @@
+import React from 'react';
+import MomentLocaleUtils from 'react-day-picker/moment';
+import moment from 'moment';
+import DayPicker from 'react-day-picker';
+
+import { shallowWithIntl } from 'utils/testUtils';
+import Resource from '../../../utils/fixtures/Resource';
+import { UnconnectedOvernightCalendar as OvernightCalendar } from '../OvernightCalendar';
+import OvernightHiddenHeading from '../OvernightHiddenHeading';
+import OvernightLegends from '../OvernightLegends';
+import OvernightSummary from '../OvernightSummary';
+import OvernightEditSummary from '../OvernightEditSummary';
+
+
+describe('app/shared/overnight-calendar/OvernightCalendar', () => {
+  const resource = Resource.build({
+    reservations: [],
+    overnightReservations: true,
+    overnightEndTime: '09:00:00',
+    overnightStartTime: '11:00:00',
+  });
+  const defaultProps = {
+    currentLanguage: 'fi',
+    resource,
+    selected: [],
+    actions: {
+      setSelectedDatetimes: () => {},
+      addNotification: () => {},
+    },
+    history: {},
+    isStaff: false,
+    isSuperuser: false,
+    isLoggedIn: false,
+    isStrongAuthSatisfied: false,
+    isMaintenanceModeOn: false,
+    onEditCancel: () => {},
+    onEditConfirm: () => {},
+    handleDateChange: () => {},
+    selectedDate: '2024-02-18',
+    params: { id: resource.id },
+  };
+
+  function getWrapper(extraProps = {}) {
+    return shallowWithIntl(<OvernightCalendar {...defaultProps} {...extraProps} />);
+  }
+
+  describe('render', () => {
+    test('null, when resource is missing reservations', () => {
+      const wrapper = getWrapper({ resource: {} });
+      expect(wrapper.html()).toBeNull();
+    });
+
+    test('wrapping div', () => {
+      const wrapper = getWrapper();
+      expect(wrapper.find('div.overnight-calendar')).toHaveLength(1);
+    });
+
+    test('OvernightHiddenHeading', () => {
+      const heading = getWrapper().find(OvernightHiddenHeading);
+      expect(heading).toHaveLength(1);
+      expect(heading.prop('date')).toEqual(moment(defaultProps.selectedDate).toDate());
+      expect(heading.prop('locale')).toBe(defaultProps.currentLanguage);
+      expect(heading.prop('localeUtils')).toBe(MomentLocaleUtils);
+    });
+
+    test('DayPicker', () => {
+      const dayPicker = getWrapper().find(DayPicker);
+      expect(dayPicker).toHaveLength(1);
+      expect(dayPicker.prop('disabledDays')).toBeDefined();
+      expect(dayPicker.prop('enableOutsideDays')).toBe(true);
+      expect(dayPicker.prop('firstDayOfWeek')).toBe(1);
+      expect(dayPicker.prop('initialMonth')).toEqual(moment(defaultProps.selectedDate).toDate());
+      expect(dayPicker.prop('labels')).toStrictEqual({ previousMonth: 'Overnight.prevMonth', nextMonth: 'Overnight.nextMonth' });
+      expect(dayPicker.prop('locale')).toBe(defaultProps.currentLanguage);
+      expect(dayPicker.prop('localeUtils')).toBe(MomentLocaleUtils);
+      expect(dayPicker.prop('modifiers')).toBeDefined();
+      expect(dayPicker.prop('onDayClick')).toBeDefined();
+      expect(dayPicker.prop('onMonthChange')).toBeDefined();
+      expect(dayPicker.prop('selectedDays')).toStrictEqual([null, null]);
+      expect(dayPicker.prop('showOutsideDays')).toBe(true);
+      expect(dayPicker.prop('todayButton')).toBe('Overnight.currentMonth');
+    });
+
+    test('OvernightLegends', () => {
+      const legends = getWrapper().find(OvernightLegends);
+      expect(legends).toHaveLength(1);
+    });
+
+    describe('when not editing', () => {
+      test('OvernightSummary', () => {
+        const summary = getWrapper().find(OvernightSummary);
+        expect(summary).toHaveLength(1);
+        expect(summary.prop('duration')).toBeDefined();
+        expect(summary.prop('endDatetime')).toBe('');
+        expect(summary.prop('handleSelectDatetimes')).toBeDefined();
+        expect(summary.prop('isDurationBelowMin')).toBe(false);
+        expect(summary.prop('minDuration')).toBe(defaultProps.resource.minPeriod);
+        expect(summary.prop('selected')).toBe(defaultProps.selected);
+        expect(summary.prop('startDatetime')).toBe('');
+      });
+
+      test('OvernightEditSummary is not rendered', () => {
+        const editSummary = getWrapper().find(OvernightEditSummary);
+        expect(editSummary).toHaveLength(0);
+      });
+    });
+
+    describe('when editing', () => {
+      // editing when something is preselected
+      const selected = [
+        {
+          begin: '2024-02-18T09:00:00',
+          end: '2024-02-19T11:00:00',
+          resource: resource.id,
+        },
+        {
+          begin: '2024-02-18T09:00:00',
+          end: '2024-02-19T11:00:00',
+          resource: resource.id,
+        }
+      ];
+
+      test('OvernightSummary is not rendered', () => {
+        const summary = getWrapper({ selected }).find(OvernightSummary);
+        expect(summary).toHaveLength(0);
+      });
+
+      test('OvernightEditSummary', () => {
+        const editSummary = getWrapper({ selected }).find(OvernightEditSummary);
+        expect(editSummary).toHaveLength(1);
+        expect(editSummary.prop('datesSameAsInitial')).toBe(true);
+        expect(editSummary.prop('duration')).toBeDefined();
+        expect(editSummary.prop('endDatetime')).toBe('19.2.2024 09:00');
+        expect(editSummary.prop('isDurationBelowMin')).toBe(false);
+        expect(editSummary.prop('minDuration')).toBe(defaultProps.resource.minPeriod);
+        expect(editSummary.prop('onCancel')).toBe(defaultProps.onEditCancel);
+        expect(editSummary.prop('onConfirm')).toBeDefined();
+        expect(editSummary.prop('selected')).toBe(selected);
+        expect(editSummary.prop('startDatetime')).toBe('18.2.2024 11:00');
+      });
+    });
+  });
+});
diff --git a/app/shared/overnight-calendar/tests/OvernightCalendarSelector.spec.js b/app/shared/overnight-calendar/tests/OvernightCalendarSelector.spec.js
new file mode 100644
index 000000000..86ac2be62
--- /dev/null
+++ b/app/shared/overnight-calendar/tests/OvernightCalendarSelector.spec.js
@@ -0,0 +1,45 @@
+import { getState } from 'utils/testUtils';
+import OvernightCalendarSelector from '../OvernightCalendarSelector';
+
+describe('app/shared/overnight-calendar/OvernightCalendarSelector', () => {
+  function getProps(id = 'some-id') {
+    return {
+      location: {
+        search: 'date=2015-10-10',
+      },
+      params: {
+        id,
+      },
+    };
+  }
+
+  function getSelected(extraState) {
+    const state = getState(extraState);
+    const props = getProps();
+    return OvernightCalendarSelector(state, props);
+  }
+
+  test('returns selected', () => {
+    expect(getSelected().selected).toBeDefined();
+  });
+
+  test('returns isMaintenanceModeOn', () => {
+    expect(getSelected().isMaintenanceModeOn).toBeDefined();
+  });
+
+  test('returns isStrongAuthSatisfied', () => {
+    expect(getSelected().isStrongAuthSatisfied).toBeDefined();
+  });
+
+  test('returns currentLanguage', () => {
+    expect(getSelected().currentLanguage).toBeDefined();
+  });
+
+  test('returns isStaff', () => {
+    expect(getSelected().isStaff).toBeDefined();
+  });
+
+  test('returns isSuperUserSelector', () => {
+    expect(getSelected().isSuperuser).toBeDefined();
+  });
+});
diff --git a/app/shared/overnight-calendar/tests/OvernightEditSummary.spec.js b/app/shared/overnight-calendar/tests/OvernightEditSummary.spec.js
new file mode 100644
index 000000000..4d97b8326
--- /dev/null
+++ b/app/shared/overnight-calendar/tests/OvernightEditSummary.spec.js
@@ -0,0 +1,109 @@
+import React from 'react';
+import moment from 'moment';
+import Button from 'react-bootstrap/lib/Button';
+
+import { shallowWithIntl } from 'utils/testUtils';
+import OvernightEditSummary from '../OvernightEditSummary';
+import { getPrettifiedPeriodUnits } from '../../../utils/timeUtils';
+
+
+describe('app/shared/overnight-calendar/OvernightEditSummary', () => {
+  const startM = moment('2024-02-23 11:00:00');
+  const endM = moment('2024-02-25 09:00:00');
+  const defaultProps = {
+    duration: moment.duration(endM.diff(startM)),
+    selected: [],
+    endDatetime: '25.2.2024 09:00',
+    startDatetime: '23.2.2024 11:00',
+    isDurationBelowMin: false,
+    minDuration: '1 00:00:00',
+    datesSameAsInitial: true,
+    onCancel: () => {},
+    onConfirm: () => {},
+  };
+
+  function getWrapper(extraProps = {}) {
+    return shallowWithIntl(<OvernightEditSummary {...defaultProps} {...extraProps} />);
+  }
+
+  describe('render', () => {
+    test('wrapping div', () => {
+      const wrapper = getWrapper().find('div.overnight-edit-summary');
+      expect(wrapper).toHaveLength(1);
+    });
+
+    test('time range div', () => {
+      const div = getWrapper().find('div.overnight-edit-time-range');
+      expect(div).toHaveLength(1);
+    });
+
+    test("time range div's status div", () => {
+      const div = getWrapper().find('.overnight-edit-time-range');
+      const statusDiv = div.find('[role="status"]');
+      expect(statusDiv).toHaveLength(1);
+    });
+
+    describe('when there is a valid time range', () => {
+      test('time range text', () => {
+        const div = getWrapper().find('.overnight-edit-time-range');
+        const text = div.find('[role="status"]');
+        const durText = getPrettifiedPeriodUnits(defaultProps.duration, 'common.unit.time.day.short');
+        expect(text.text()).toEqual(
+          `TimeSlots.selectedDate 23.2.2024 11:00 - 25.2.2024 09:00 (${durText})`);
+      });
+    });
+
+    describe('when there is an invalid time range', () => {
+      const startDatetime = '';
+      const div = getWrapper({ startDatetime }).find('.overnight-edit-time-range');
+      const statusDiv = div.find('[role="status"]');
+      expect(statusDiv.text()).toEqual('');
+    });
+
+    describe('when there is min duration error', () => {
+      test('error text', () => {
+        const paragraph = getWrapper({ datesSameAsInitial: false, isDurationBelowMin: true }).find('p.overnight-error');
+        const minDurationText = getPrettifiedPeriodUnits(defaultProps.minDuration, 'common.unit.time.day.short');
+        expect(paragraph).toHaveLength(1);
+        expect(paragraph.text()).toEqual(`Overnight.belowMinAlert (${minDurationText})`);
+      });
+    });
+
+    describe('when there isnt min duration error', () => {
+      test('doesnt render error text', () => {
+        const paragraph = getWrapper({ datesSameAsInitial: false, isDurationBelowMin: false }).find('p.overnight-error');
+        expect(paragraph).toHaveLength(0);
+      });
+    });
+
+    test('reservation controls wrapping div', () => {
+      const div = getWrapper().find('div.app-ReservationTime__controls');
+      expect(div).toHaveLength(1);
+    });
+
+    describe('reservation control buttons', () => {
+      const buttons = getWrapper().find(Button);
+
+      test('correct amount of buttons', () => {
+        expect(buttons).toHaveLength(2);
+      });
+
+      test('first button', () => {
+        const firstButton = buttons.first();
+        expect(firstButton.prop('bsStyle')).toBe('warning');
+        expect(firstButton.prop('className')).toBe('cancel_Button');
+        expect(firstButton.prop('onClick')).toBe(defaultProps.onCancel);
+        expect(firstButton.prop('children')).toBe('ReservationInformationForm.cancelEdit');
+      });
+
+      test('second button', () => {
+        const secondButton = buttons.last();
+        expect(secondButton.prop('bsStyle')).toBe('primary');
+        expect(secondButton.prop('className')).toBe('next_Button');
+        expect(secondButton.prop('disabled')).toBe(false);
+        expect(secondButton.prop('onClick')).toBe(defaultProps.onConfirm);
+        expect(secondButton.prop('children')).toBe('common.continue');
+      });
+    });
+  });
+});
diff --git a/app/shared/overnight-calendar/tests/OvernightHiddenHeading.spec.js b/app/shared/overnight-calendar/tests/OvernightHiddenHeading.spec.js
new file mode 100644
index 000000000..941357d0b
--- /dev/null
+++ b/app/shared/overnight-calendar/tests/OvernightHiddenHeading.spec.js
@@ -0,0 +1,42 @@
+import React from 'react';
+import moment from 'moment';
+import MomentLocaleUtils from 'react-day-picker/moment';
+
+import { shallowWithIntl } from 'utils/testUtils';
+import OvernightHiddenHeading from '../OvernightHiddenHeading';
+
+
+describe('app/shared/overnight-calendar/OvernightHiddenHeading', () => {
+  const defaultProps = {
+    date: moment('2024-02-23').toDate(),
+    localeUtils: MomentLocaleUtils,
+    locale: 'fi',
+  };
+
+  function getWrapper(extraProps = {}) {
+    return shallowWithIntl(<OvernightHiddenHeading {...defaultProps} {...extraProps} />);
+  }
+
+  describe('render', () => {
+    test('wrapping div', () => {
+      const wrapper = getWrapper();
+      expect(wrapper).toHaveLength(1);
+      expect(wrapper.prop('className')).toBe('sr-only');
+    });
+
+    test('heading', () => {
+      const heading = getWrapper().find('h3');
+      expect(heading).toHaveLength(1);
+      expect(heading.text()).toBe('Overnight.calendar');
+    });
+
+    test('paragraph', () => {
+      const paragraph = getWrapper().find('p');
+      const { localeUtils, locale, date } = defaultProps;
+      const expectedText = localeUtils.formatMonthTitle(date, locale);
+      expect(paragraph).toHaveLength(1);
+      expect(paragraph.prop('role')).toBe('status');
+      expect(paragraph.text()).toBe(expectedText);
+    });
+  });
+});
diff --git a/app/shared/overnight-calendar/tests/OvernightLegends.spec.js b/app/shared/overnight-calendar/tests/OvernightLegends.spec.js
new file mode 100644
index 000000000..dcc485e1f
--- /dev/null
+++ b/app/shared/overnight-calendar/tests/OvernightLegends.spec.js
@@ -0,0 +1,60 @@
+import React from 'react';
+
+import { shallowWithIntl } from 'utils/testUtils';
+import OvernightLegends from '../OvernightLegends';
+
+
+describe('app/shared/overnight-calendar/OvernightLegends', () => {
+  function getWrapper(extraProps = {}) {
+    return shallowWithIntl(<OvernightLegends {...extraProps} />);
+  }
+
+  describe('render', () => {
+    test('wrapping div', () => {
+      const wrapper = getWrapper();
+      expect(wrapper).toHaveLength(1);
+      expect(wrapper.prop('className')).toBe('overnight-legends');
+      expect(wrapper.prop('aria-hidden')).toBe(true);
+    });
+
+    test('rows', () => {
+      const rows = getWrapper().find('div.overnight-row');
+      expect(rows).toHaveLength(2);
+    });
+
+    test('legends', () => {
+      const legends = getWrapper().find('div.overnight-legend');
+      expect(legends).toHaveLength(4);
+    });
+
+    test('legend boxes', () => {
+      const legends = getWrapper().find('div.overnight-legend-box');
+      expect(legends).toHaveLength(4);
+      const box1 = legends.at(0);
+      expect(box1.prop('className')).toBe('overnight-legend-box overnight-free');
+      expect(box1.text()).toBe('21');
+      const box2 = legends.at(1);
+      expect(box2.prop('className')).toBe('overnight-legend-box overnight-disabled');
+      expect(box2.text()).toBe('21');
+      const box3 = legends.at(2);
+      expect(box3.prop('className')).toBe('overnight-legend-box overnight-booked');
+      expect(box3.text()).toBe('21');
+      const box4 = legends.at(3);
+      expect(box4.prop('className')).toBe('overnight-legend-box overnight-selection');
+      expect(box4.text()).toBe('21');
+    });
+
+    test('legend texts', () => {
+      const legends = getWrapper().find('span.overnight-legend-text');
+      expect(legends).toHaveLength(4);
+      const text1 = legends.at(0);
+      expect(text1.text()).toBe('Overnight.legend.available');
+      const text2 = legends.at(1);
+      expect(text2.text()).toBe('Overnight.legend.notSelectable');
+      const text3 = legends.at(2);
+      expect(text3.text()).toBe('Overnight.legend.reserved');
+      const text4 = legends.at(3);
+      expect(text4.text()).toBe('Overnight.legend.ownSelection');
+    });
+  });
+});
diff --git a/app/shared/overnight-calendar/tests/OvernightSummary.spec.js b/app/shared/overnight-calendar/tests/OvernightSummary.spec.js
new file mode 100644
index 000000000..bba7bb550
--- /dev/null
+++ b/app/shared/overnight-calendar/tests/OvernightSummary.spec.js
@@ -0,0 +1,95 @@
+import React from 'react';
+import moment from 'moment';
+import Button from 'react-bootstrap/lib/Button';
+
+import { shallowWithIntl } from 'utils/testUtils';
+import { getPrettifiedPeriodUnits } from '../../../utils/timeUtils';
+import OvernightSummary from '../OvernightSummary';
+
+
+describe('app/shared/overnight-calendar/OvernightSummary', () => {
+  const startM = moment('2024-02-23 11:00:00');
+  const endM = moment('2024-02-25 09:00:00');
+  const defaultProps = {
+    duration: moment.duration(endM.diff(startM)),
+    selected: [],
+    endDatetime: '25.2.2024 09:00',
+    startDatetime: '23.2.2024 11:00',
+    isDurationBelowMin: false,
+    minDuration: '1 00:00:00',
+    handleSelectDatetimes: () => {},
+  };
+
+  function getWrapper(extraProps = {}) {
+    return shallowWithIntl(<OvernightSummary {...defaultProps} {...extraProps} />);
+  }
+
+  describe('render', () => {
+    describe('wrapping div', () => {
+      test('when there is valid time range', () => {
+        const wrapper = getWrapper().find('div.overnight-summary');
+        expect(wrapper).toHaveLength(1);
+      });
+      test('when there isnt valid time range', () => {
+        const startDatetime = '';
+        const wrapper = getWrapper({ startDatetime }).find('div.overnight-summary');
+        expect(wrapper).toHaveLength(1);
+        expect(wrapper.prop('className')).toBe('overnight-summary sr-only');
+      });
+    });
+
+    test('hidden h3', () => {
+      const heading = getWrapper().find('h3.visually-hidden');
+      expect(heading).toHaveLength(1);
+      expect(heading.text()).toEqual('ReservationCalendar.Confirmation.header');
+      expect(heading.prop('id')).toBe('timetable-summary');
+    });
+
+    test('time range div', () => {
+      const div = getWrapper().find('div.summary-time-range');
+      expect(div).toHaveLength(1);
+      expect(div.prop('role')).toBe('status');
+    });
+
+    describe('when there is a valid time range', () => {
+      test('time range text', () => {
+        const div = getWrapper().find('.summary-time-range');
+        const durText = getPrettifiedPeriodUnits(defaultProps.duration, 'common.unit.time.day.short');
+        expect(div.text()).toEqual(
+          `TimeSlots.selectedDate 23.2.2024 11:00 - 25.2.2024 09:00 (${durText})`);
+      });
+    });
+
+    describe('when there is an invalid time range', () => {
+      test('doesnt render time range', () => {
+        const startDatetime = '';
+        const div = getWrapper({ startDatetime }).find('.summary-time-range');
+        expect(div.text()).toEqual('');
+      });
+    });
+
+    describe('when there is min duration error', () => {
+      test('error text', () => {
+        const paragraph = getWrapper({ datesSameAsInitial: false, isDurationBelowMin: true }).find('p.overnight-error');
+        const minDurationText = getPrettifiedPeriodUnits(defaultProps.minDuration, 'common.unit.time.day.short');
+        expect(paragraph).toHaveLength(1);
+        expect(paragraph.text()).toEqual(`Overnight.belowMinAlert (${minDurationText})`);
+      });
+    });
+
+    describe('when there isnt min duration error', () => {
+      test('doesnt render error text', () => {
+        const paragraph = getWrapper({ datesSameAsInitial: false, isDurationBelowMin: false }).find('p.overnight-error');
+        expect(paragraph).toHaveLength(0);
+      });
+    });
+
+    test('reserve button', () => {
+      const button = getWrapper().find(Button);
+      expect(button.prop('bsStyle')).toBe('primary');
+      expect(button.prop('disabled')).toBe(false);
+      expect(button.prop('onClick')).toBe(defaultProps.handleSelectDatetimes);
+      expect(button.prop('children')).toBe('TimeSlots.reserveButton');
+    });
+  });
+});
diff --git a/app/shared/overnight-calendar/tests/overnightUtils.spec.js b/app/shared/overnight-calendar/tests/overnightUtils.spec.js
new file mode 100644
index 000000000..6acae358e
--- /dev/null
+++ b/app/shared/overnight-calendar/tests/overnightUtils.spec.js
@@ -0,0 +1,718 @@
+import moment from 'moment';
+
+import {
+  areDatesSameAsInitialDates,
+  filterSelectedReservation,
+  findFirstClosedDay,
+  findFirstClosestReservation,
+  findPrevFirstClosedDay,
+  findPrevFirstClosestReservation,
+  getClosedDays,
+  getFirstBlockedDay,
+  getHoursMinutesSeconds,
+  getNotSelectableNotificationText,
+  getNotificationText,
+  getOvernightDatetime,
+  getReservationUrl,
+  getSelectedDuration,
+  handleDateSelect,
+  handleDisableDays,
+  handleFormattingSelected,
+  isDurationBelowMin,
+  isOverMaxPeriod,
+  isReservingAllowed,
+  nextDayBookedModifier,
+  nextDayClosedModifier,
+  prevDayBookedModifier,
+  prevDayClosedModifier,
+  reservationsModifier,
+  setDatesTime
+} from '../overnightUtils';
+import Reservation from '../../../utils/fixtures/Reservation';
+import Resource from '../../../utils/fixtures/Resource';
+
+describe('app/shared/overnight-calendar/overnightUtils', () => {
+  describe('handleDateSelect', () => {
+    test('returns undefined when value if falsy', () => {
+      expect(handleDateSelect({ value: null })).toBeUndefined();
+    });
+
+    test('sets startDate when value is not set', () => {
+      const setStartDate = jest.fn();
+      const val = new Date();
+      const overnightStartTime = '11:00:00';
+      const expectedCall = setDatesTime(val, overnightStartTime).toDate();
+      handleDateSelect({
+        value: val, startDate: null, setStartDate, overnightStartTime
+      });
+      expect(setStartDate).toHaveBeenCalled();
+      expect(setStartDate).toHaveBeenCalledWith(expectedCall);
+    });
+
+    test('sets startDate and endDate to null if start is selected and same as value', () => {
+      const setStartDate = jest.fn();
+      const setEndDate = jest.fn();
+      const overnightStartTime = '11:00:00';
+      const date = setDatesTime(new Date(), overnightStartTime).toDate();
+      handleDateSelect({
+        value: date, startDate: date, setStartDate, setEndDate, overnightStartTime
+      });
+      expect(setStartDate).toHaveBeenCalled();
+      expect(setStartDate).toHaveBeenCalledWith(null);
+      expect(setEndDate).toHaveBeenCalled();
+      expect(setEndDate).toHaveBeenCalledWith(null);
+    });
+
+    test('sets endDate if startDate already set, value is not same as start and endDate not set', () => {
+      const setStartDate = jest.fn();
+      const setEndDate = jest.fn();
+      const overnightStartTime = '11:00:00';
+      const overnightEndTime = '13:00:00';
+      const val = new Date();
+      const start = new Date('2024-02-21');
+      const expectedCall = setDatesTime(val, overnightEndTime).toDate();
+      handleDateSelect({
+        value: val,
+        startDate: start,
+        setStartDate,
+        setEndDate,
+        overnightStartTime,
+        overnightEndTime
+      });
+      expect(setEndDate).toHaveBeenCalled();
+      expect(setEndDate).toHaveBeenCalledWith(expectedCall);
+    });
+
+    test('sets startDate and endDate to null if start and end are selected and end is same as value', () => {
+      const setStartDate = jest.fn();
+      const setEndDate = jest.fn();
+      const overnightStartTime = '11:00:00';
+      const overnightEndTime = '13:00:00';
+      const val = new Date();
+      const start = new Date('2024-02-21');
+      const end = setDatesTime(val, overnightEndTime).toDate();
+      handleDateSelect({
+        value: val,
+        startDate: start,
+        endDate: end,
+        setStartDate,
+        setEndDate,
+        overnightStartTime,
+        overnightEndTime
+      });
+      expect(setStartDate).toHaveBeenCalled();
+      expect(setStartDate).toHaveBeenCalledWith(null);
+      expect(setEndDate).toHaveBeenCalled();
+      expect(setEndDate).toHaveBeenCalledWith(null);
+    });
+  });
+
+  describe('handleDisableDays', () => {
+    const now = moment('2024-04-20');
+    const day = now.toDate();
+    const reservable = true;
+    const reservableAfter = '2024-04-19T00:00:00+03:00';
+    const reservableBefore = '2024-04-29T00:00:00+03:00';
+    const startDate = null;
+    const openingHours = [
+      { date: '2024-04-19', closes: null, opens: null },
+      { date: '2024-04-20', closes: '2024-04-20T20:00:00+03:00', opens: '2024-04-20T06:00:00+03:00' },
+      { date: '2024-04-21', closes: '2024-04-21T20:00:00+03:00', opens: '2024-04-21T06:00:00+03:00' },
+      { date: '2024-04-22', closes: '2024-04-22T20:00:00+03:00', opens: '2024-04-22T06:00:00+03:00' },
+      { date: '2024-04-23', closes: '2024-04-23T20:00:00+03:00', opens: '2024-04-23T06:00:00+03:00' },
+      { date: '2024-04-24', closes: '2024-04-24T20:00:00+03:00', opens: '2024-04-24T06:00:00+03:00' },
+      { date: '2024-04-25', closes: '2024-04-25T20:00:00+03:00', opens: '2024-04-25T06:00:00+03:00' },
+      { date: '2024-04-26', closes: '2024-04-26T20:00:00+03:00', opens: '2024-04-26T06:00:00+03:00' },
+      { date: '2024-04-27', closes: '2024-04-27T20:00:00+03:00', opens: '2024-04-27T06:00:00+03:00' },
+      { date: '2024-04-28', closes: '2024-04-28T20:00:00+03:00', opens: '2024-04-28T06:00:00+03:00' },
+      { date: '2024-04-29', closes: '2024-04-29T20:00:00+03:00', opens: '2024-04-29T06:00:00+03:00' },
+      { date: '2024-04-30', closes: null, opens: null },
+    ];
+    const reservations = [
+      Reservation.build({ begin: '2024-04-23T13:00:00+03:00', end: '2024-04-24T09:00:00+03:00' })
+    ];
+    const maxPeriod = '3 00:00:00';
+    const overnightEndTime = '09:00:00';
+    const overnightStartTime = '13:00:00';
+    const hasAdminBypass = false;
+    const params = {
+      now,
+      day,
+      reservable,
+      reservableAfter,
+      reservableBefore,
+      startDate,
+      openingHours,
+      reservations,
+      maxPeriod,
+      overnightEndTime,
+      overnightStartTime,
+      hasAdminBypass
+    };
+
+    test('returns false with correct params', () => {
+      expect(handleDisableDays(params)).toBe(false);
+    });
+
+    describe('returns true when', () => {
+      test('no admin bypass and not reservable', () => {
+        expect(handleDisableDays(
+          { ...params, hasAdminBypass: false, reservable: false }
+        )).toBe(true);
+      });
+
+      test('now is after given day', () => {
+        expect(handleDisableDays(
+          {
+            ...params,
+            now: moment('2024-04-21')
+          }
+        )).toBe(true);
+      });
+
+      test('day is before reservable after limit', () => {
+        expect(handleDisableDays(
+          {
+            ...params,
+            reservableAfter: '2024-04-21T01:00:00+03:00'
+          }
+        )).toBe(true);
+      });
+
+      test('day is after reservable before limit', () => {
+        expect(handleDisableDays(
+          {
+            ...params,
+            day: moment('2024-04-29').toDate(),
+            reservableBefore: '2024-04-28T01:00:00+03:00'
+          }
+        )).toBe(true);
+      });
+
+      test('day is before selected start date', () => {
+        expect(handleDisableDays(
+          {
+            ...params,
+            day: moment('2024-04-24').toDate(),
+            startDate: moment('2024-04-26').toDate(),
+          }
+        )).toBe(true);
+      });
+
+      test('day has reservation', () => {
+        expect(handleDisableDays(
+          {
+            ...params,
+            day: moment('2024-04-23').toDate(),
+          }
+        )).toBe(true);
+      });
+
+      test('day is closed', () => {
+        expect(handleDisableDays(
+          {
+            ...params,
+            day: moment('2024-04-19').toDate(),
+          }
+        )).toBe(true);
+      });
+
+      test('day is over max reservation time', () => {
+        expect(handleDisableDays(
+          {
+            ...params,
+            day: moment('2024-04-29').toDate(),
+            startDate: moment('2024-04-25').toDate(),
+          }
+        )).toBe(true);
+      });
+
+      test('day is after a reservation or closed day when startDate is selected', () => {
+        expect(handleDisableDays(
+          {
+            ...params,
+            maxPeriod: '10 00:00:00',
+            day: moment('2024-04-25').toDate(),
+            startDate: moment('2024-04-22').toDate(),
+          }
+        )).toBe(true);
+      });
+    });
+  });
+
+  describe('isOverMaxPeriod', () => {
+    const overnightEndTime = '09:00:00';
+    const overnightStartTime = '13:00:00';
+    const startDate = moment('2024-04-20').toDate();
+    const endDate = moment('2024-04-22').toDate();
+
+    test('returns false when not over max period', () => {
+      expect(isOverMaxPeriod(
+        startDate, endDate, '10 00:00:00', overnightEndTime, overnightStartTime
+      )).toBe(false);
+    });
+
+    test('returns true when over max period', () => {
+      expect(isOverMaxPeriod(
+        startDate, endDate, '1 10:00:00', overnightEndTime, overnightStartTime
+      )).toBe(true);
+    });
+  });
+
+  describe('getClosedDays', () => {
+    test('returns closed days', () => {
+      const openingHours = [
+        { date: '2024-04-19', closes: null, opens: null },
+        { date: '2024-04-20', closes: '2024-04-20T20:00:00+03:00', opens: '2024-04-20T06:00:00+03:00' },
+        { date: '2024-04-21', closes: '2024-04-21T20:00:00+03:00', opens: '2024-04-21T06:00:00+03:00' },
+        { date: '2024-04-22', closes: '2024-04-22T20:00:00+03:00', opens: '2024-04-22T06:00:00+03:00' },
+        { date: '2024-04-23', closes: '2024-04-23T20:00:00+03:00', opens: '2024-04-23T06:00:00+03:00' },
+        { date: '2024-04-24', closes: null, opens: null },
+      ];
+      expect(getClosedDays(openingHours)).toStrictEqual([openingHours[0], openingHours[5]]);
+    });
+  });
+
+  describe('reservationsModifier', () => {
+    const reservations = [
+      Reservation.build({ begin: '2024-04-23T13:00:00+03:00', end: '2024-04-24T09:00:00+03:00' })
+    ];
+    test('returns true when day has reservation', () => {
+      expect(reservationsModifier(
+        moment('2024-04-23').toDate(), reservations)).toBe(true);
+      expect(reservationsModifier(
+        moment('2024-04-24').toDate(), reservations)).toBe(true);
+    });
+
+    test('returns false when day has no reservation', () => {
+      expect(reservationsModifier(
+        moment('2024-04-22').toDate(), reservations)).toBe(false);
+      expect(reservationsModifier(
+        moment('2024-04-25').toDate(), reservations)).toBe(false);
+    });
+  });
+
+  describe('nextDayBookedModifier', () => {
+    const reservations = [
+      Reservation.build({ begin: '2024-04-23T13:00:00+03:00', end: '2024-04-24T09:00:00+03:00' })
+    ];
+    test('returns true when next day has reservation', () => {
+      expect(nextDayBookedModifier(
+        moment('2024-04-22').toDate(), reservations)).toBe(true);
+    });
+
+    test('returns false when next day has no reservation', () => {
+      expect(nextDayBookedModifier(
+        moment('2024-04-20').toDate(), reservations)).toBe(false);
+      expect(nextDayBookedModifier(
+        moment('2024-04-24').toDate(), reservations)).toBe(false);
+    });
+  });
+
+  describe('prevDayBookedModifier', () => {
+    const reservations = [
+      Reservation.build({ begin: '2024-04-23T13:00:00+03:00', end: '2024-04-24T09:00:00+03:00' })
+    ];
+    test('returns true when previous day has reservation', () => {
+      expect(prevDayBookedModifier(
+        moment('2024-04-25').toDate(), reservations)).toBe(true);
+    });
+
+    test('returns false when previous day has no reservation', () => {
+      expect(prevDayBookedModifier(
+        moment('2024-04-21').toDate(), reservations)).toBe(false);
+      expect(prevDayBookedModifier(
+        moment('2024-04-23').toDate(), reservations)).toBe(false);
+    });
+  });
+
+  describe('nextDayClosedModifier', () => {
+    const openingHours = [
+      { date: '2024-04-19', closes: null, opens: null },
+      { date: '2024-04-20', closes: '2024-04-20T20:00:00+03:00', opens: '2024-04-20T06:00:00+03:00' },
+      { date: '2024-04-21', closes: '2024-04-21T20:00:00+03:00', opens: '2024-04-21T06:00:00+03:00' },
+      { date: '2024-04-22', closes: '2024-04-22T20:00:00+03:00', opens: '2024-04-22T06:00:00+03:00' },
+      { date: '2024-04-23', closes: '2024-04-23T20:00:00+03:00', opens: '2024-04-23T06:00:00+03:00' },
+      { date: '2024-04-24', closes: null, opens: null },
+    ];
+    test('returns true when next day is closed', () => {
+      expect(nextDayClosedModifier(
+        moment('2024-04-23').toDate(), openingHours)).toBe(true);
+    });
+
+    test('returns false when next day is not closed', () => {
+      expect(nextDayClosedModifier(
+        moment('2024-04-20').toDate(), openingHours)).toBe(false);
+      expect(nextDayClosedModifier(
+        moment('2024-04-24').toDate(), openingHours)).toBe(false);
+    });
+  });
+
+  describe('prevDayClosedModifier', () => {
+    const openingHours = [
+      { date: '2024-04-19', closes: null, opens: null },
+      { date: '2024-04-20', closes: '2024-04-20T20:00:00+03:00', opens: '2024-04-20T06:00:00+03:00' },
+      { date: '2024-04-21', closes: '2024-04-21T20:00:00+03:00', opens: '2024-04-21T06:00:00+03:00' },
+      { date: '2024-04-22', closes: '2024-04-22T20:00:00+03:00', opens: '2024-04-22T06:00:00+03:00' },
+      { date: '2024-04-23', closes: '2024-04-23T20:00:00+03:00', opens: '2024-04-23T06:00:00+03:00' },
+      { date: '2024-04-24', closes: null, opens: null },
+    ];
+    test('returns true when previous day is closed', () => {
+      expect(prevDayClosedModifier(
+        moment('2024-04-20').toDate(), openingHours)).toBe(true);
+    });
+
+    test('returns false when previous day is not closed', () => {
+      expect(prevDayClosedModifier(
+        moment('2024-04-21').toDate(), openingHours)).toBe(false);
+      expect(prevDayClosedModifier(
+        moment('2024-04-24').toDate(), openingHours)).toBe(false);
+    });
+  });
+
+  describe('findFirstClosedDay', () => {
+    test('returns first closed day', () => {
+      const openingHours = [
+        { date: '2024-04-22', closes: null, opens: null },
+        { date: '2024-04-23', closes: null, opens: null },
+        { date: '2024-04-24', closes: null, opens: null },
+      ];
+      expect(findFirstClosedDay(moment('2024-04-23').toDate(), openingHours))
+        .toBe(openingHours[2].date);
+    });
+    test('returns null if no closed day', () => {
+      const openingHours = [
+        { date: '2024-04-22', closes: null, opens: null },
+        { date: '2024-04-23', closes: null, opens: null },
+        { date: '2024-04-24', closes: null, opens: null },
+      ];
+      expect(findFirstClosedDay(moment('2024-04-25').toDate(), openingHours))
+        .toBe(null);
+    });
+  });
+
+  describe('findPrevFirstClosedDay', () => {
+    const openingHours = [
+      { date: '2024-04-22', closes: null, opens: null },
+      { date: '2024-04-23', closes: null, opens: null },
+      { date: '2024-04-24', closes: null, opens: null },
+    ];
+    test('returns first closed day', () => {
+      expect(findPrevFirstClosedDay(moment('2024-04-23').toDate(), openingHours))
+        .toBe(openingHours[0].date);
+      expect(findPrevFirstClosedDay(moment('2024-04-24').toDate(), openingHours))
+        .toBe(openingHours[1].date);
+    });
+    test('returns null if no closed day', () => {
+      expect(findPrevFirstClosedDay(moment('2024-04-22').toDate(), openingHours))
+        .toBe(null);
+    });
+  });
+
+  describe('findFirstClosestReservation', () => {
+    const reservations = [
+      Reservation.build({
+        begin: '2024-04-23T13:00:00+03:00',
+        end: '2024-04-24T09:00:00+03:00'
+      }),
+      Reservation.build({
+        begin: '2024-04-25T13:00:00+03:00',
+        end: '2024-04-27T09:00:00+03:00'
+      })
+    ];
+    test('returns closest reservation', () => {
+      expect(findFirstClosestReservation(moment('2024-04-20').toDate(), reservations))
+        .toBe(reservations[0]);
+      expect(findFirstClosestReservation(moment('2024-04-24').toDate(), reservations))
+        .toBe(reservations[1]);
+    });
+    test('returns null if no closed day', () => {
+      expect(findFirstClosestReservation(moment('2024-04-27').toDate(), reservations))
+        .toBe(null);
+    });
+  });
+
+  describe('findPrevFirstClosestReservation', () => {
+    const reservations = [
+      Reservation.build({
+        begin: '2024-04-23T13:00:00+03:00',
+        end: '2024-04-24T09:00:00+03:00'
+      }),
+      Reservation.build({
+        begin: '2024-04-25T13:00:00+03:00',
+        end: '2024-04-27T09:00:00+03:00'
+      })
+    ];
+    test('returns closest reservation', () => {
+      expect(findPrevFirstClosestReservation(moment('2024-04-25').toDate(), reservations))
+        .toBe(reservations[0]);
+      expect(findPrevFirstClosestReservation(moment('2024-04-29').toDate(), reservations))
+        .toBe(reservations[1]);
+    });
+    test('returns null if no closed day', () => {
+      expect(findPrevFirstClosestReservation(moment('2024-04-22').toDate(), reservations))
+        .toBe(null);
+    });
+  });
+
+  describe('getFirstBlockedDay', () => {
+    const openingHours = [
+      { date: '2024-04-22', closes: null, opens: null },
+      { date: '2024-04-23', closes: null, opens: null },
+      { date: '2024-04-24', closes: null, opens: null },
+    ];
+
+    const reservations = [
+      Reservation.build({
+        begin: '2024-04-23T13:00:00+03:00',
+        end: '2024-04-24T09:00:00+03:00'
+      }),
+      Reservation.build({
+        begin: '2024-04-25T13:00:00+03:00',
+        end: '2024-04-27T09:00:00+03:00'
+      })
+    ];
+
+    test('returns first blocked day', () => {
+      expect(getFirstBlockedDay(moment('2024-04-20').toDate(), reservations, openingHours))
+        .toBe(openingHours[0].date);
+      expect(getFirstBlockedDay(moment('2024-04-24').toDate(), reservations, openingHours))
+        .toBe(reservations[1].begin);
+      expect(getFirstBlockedDay(moment('2024-04-20').toDate(), reservations, []))
+        .toBe(reservations[0].begin);
+      expect(getFirstBlockedDay(moment('2024-04-23').toDate(), [], openingHours))
+        .toBe(openingHours[2].date);
+    });
+
+    test('returns null if no blocking day found', () => {
+      expect(getFirstBlockedDay(moment('2024-04-28').toDate(), reservations, openingHours))
+        .toBe(null);
+    });
+  });
+
+  describe('setDatesTime', () => {
+    test('sets time correctly to moment obj', () => {
+      const date = moment('2024-04-23').toDate();
+      const time = '10:30:00';
+      const result = setDatesTime(date, time);
+      expect(result).toEqual(moment(date).set({
+        hour: 10, minute: 30, second: 0, millisecond: 0
+      }));
+    });
+  });
+
+  describe('getOvernightDatetime', () => {
+    test('returns correct datetime string', () => {
+      const date = moment('2024-04-23').toDate();
+      const time = '10:30:00';
+      const result = getOvernightDatetime(date, time);
+      expect(result).toBe('23.4.2024 10:30');
+    });
+    test('returns empty string when date or time is missing', () => {
+      expect(getOvernightDatetime(null, null)).toBe('');
+      expect(getOvernightDatetime(null, '10:30:00')).toBe('');
+      expect(getOvernightDatetime(moment('2024-04-23').toDate(), null)).toBe('');
+    });
+  });
+
+  describe('getHoursMinutesSeconds', () => {
+    test('returns correct obj', () => {
+      expect(getHoursMinutesSeconds('10:30:00')).toStrictEqual(
+        { hours: 10, minutes: 30, seconds: 0 });
+      expect(getHoursMinutesSeconds('00:30:00')).toStrictEqual(
+        { hours: 0, minutes: 30, seconds: 0 });
+      expect(getHoursMinutesSeconds(undefined)).toStrictEqual(
+        { hours: 0, minutes: 0, seconds: 0 });
+    });
+  });
+
+  describe('handleFormattingSelected', () => {
+    test('returns correct obj', () => {
+      const startDate = moment('2024-04-23').toDate();
+      const endDate = moment('2024-04-26').toDate();
+      const startTime = '10:30:00';
+      const endTime = '12:30:00';
+      const resourceId = 'abc123';
+      expect(handleFormattingSelected(
+        startDate, endDate, startTime, endTime, resourceId))
+        .toStrictEqual({
+          begin: '2024-04-23T07:30:00.000Z',
+          end: '2024-04-26T09:30:00.000Z',
+          resource: resourceId
+        });
+    });
+  });
+
+  describe('getReservationUrl', () => {
+    test('returns correct url string', () => {
+      const reservation = Reservation.build({ id: 'res123' });
+      expect(getReservationUrl(reservation, 'abc123'))
+        .toBe('/reservation?id=res123&resource=abc123');
+    });
+  });
+
+  describe('isReservingAllowed', () => {
+    const params = {
+      isLoggedIn: true,
+      isStrongAuthSatisfied: true,
+      isMaintenanceModeOn: false,
+      resource: Resource.build(),
+      hasAdminBypass: false
+    };
+    describe('returns false when', () => {
+      test('maintenance mode is on', () => {
+        expect(isReservingAllowed({ ...params, isMaintenanceModeOn: true }))
+          .toBe(false);
+      });
+      test('resource is missing', () => {
+        expect(isReservingAllowed({ ...params, resource: undefined }))
+          .toBe(false);
+      });
+      test('resource is not reservable', () => {
+        expect(isReservingAllowed(
+          { ...params, resource: Resource.build({ reservable: false }) }))
+          .toBe(false);
+      });
+      test('auth required and not logged in', () => {
+        expect(isReservingAllowed(
+          { ...params, isLoggedIn: false }))
+          .toBe(false);
+        expect(isReservingAllowed(
+          { ...params, isStrongAuthSatisfied: false }))
+          .toBe(false);
+      });
+    });
+    describe('returns true when', () => {
+      test('has admin bypass', () => {
+        expect(isReservingAllowed({ ...params, hasAdminBypass: true }))
+          .toBe(true);
+      });
+      test('auth not required and not logged in', () => {
+        expect(isReservingAllowed(
+          {
+            ...params,
+            resource: Resource.build({ authentication: 'unauthenticated' }),
+            isLoggedIn: false,
+            isStrongAuthSatisfied: false,
+          }))
+          .toBe(true);
+      });
+    });
+  });
+
+  describe('getNotificationText', () => {
+    const params = {
+      isLoggedIn: true,
+      isStrongAuthSatisfied: true,
+      isMaintenanceModeOn: false,
+      resource: Resource.build(),
+      t: str => str,
+    };
+    describe('returns correct text', () => {
+      test('when maintenance mode is on', () => {
+        expect(getNotificationText({ ...params, isMaintenanceModeOn: true }))
+          .toBe('Notifications.cannotReserveDuringMaintenance');
+      });
+      test('when strong auth required', () => {
+        expect(getNotificationText({ ...params, isStrongAuthSatisfied: false }))
+          .toBe('Notifications.loginToReserveStrongAuth');
+      });
+      test('when login required', () => {
+        expect(getNotificationText({ ...params, isLoggedIn: false }))
+          .toBe('Notifications.loginToReserve');
+      });
+      test('default text when login ok and no maintenance mode', () => {
+        expect(getNotificationText({ ...params }))
+          .toBe('Notifications.noRightToReserve');
+      });
+    });
+  });
+
+  describe('getNotSelectableNotificationText', () => {
+    const params = {
+      isDateDisabled: false,
+      booked: false,
+      isNextBlocked: false,
+      t: str => str,
+    };
+    describe('returns correct text', () => {
+      test('when date not disabled, not booked and next is blocked', () => {
+        expect(getNotSelectableNotificationText({ ...params, isNextBlocked: true }))
+          .toBe('Notifications.overnight.notSelectableStart');
+      });
+      test('default text', () => {
+        expect(getNotSelectableNotificationText({ ...params }))
+          .toBe('Notifications.overnight.notSelectable');
+      });
+    });
+  });
+
+  describe('filterSelectedReservation', () => {
+    test('returns correct reservations', () => {
+      const reservations = [
+        Reservation.build({ id: 'res1' }),
+        Reservation.build({ id: 'res2' }),
+        Reservation.build({ id: 'res3' }),
+      ];
+      expect(filterSelectedReservation('res2', reservations))
+        .toStrictEqual([reservations[0], reservations[2]]);
+      expect(filterSelectedReservation('res5', reservations))
+        .toStrictEqual([reservations[0], reservations[1], reservations[2]]);
+    });
+  });
+
+  describe('getSelectedDuration', () => {
+    test('returns correct duration', () => {
+      const startDate = moment('2024-04-23').toDate();
+      const endDate = moment('2024-04-26').toDate();
+      const overnightStartTime = '10:30:00';
+      const overnightEndTime = '12:30:00';
+      const expected = moment.duration(
+        setDatesTime(endDate, overnightEndTime).diff(setDatesTime(startDate, overnightStartTime)));
+      expect(getSelectedDuration(startDate, endDate, overnightStartTime, overnightEndTime))
+        .toStrictEqual(expected);
+    });
+  });
+
+  describe('isDurationBelowMin', () => {
+    test('returns correct result', () => {
+      expect(isDurationBelowMin(moment.duration(2, 'days'), '10:00:00')).toBe(false);
+      expect(isDurationBelowMin(moment.duration(2, 'days'), '3 10:00:00')).toBe(true);
+      expect(isDurationBelowMin(moment.duration(3, 'days'), '3 10:00:00')).toBe(true);
+      expect(isDurationBelowMin(moment.duration(4, 'days'), '3 10:00:00')).toBe(false);
+    });
+  });
+
+  describe('areDatesSameAsInitialDates', () => {
+    const startDate = moment('2024-04-23').toDate();
+    const endDate = moment('2024-04-26').toDate();
+    const initialStart = moment('2024-04-23').toDate();
+    const initialEnd = moment('2024-04-26').toDate();
+    test('returns false when any of the params is missing', () => {
+      expect(areDatesSameAsInitialDates(null, null, null, undefined))
+        .toBe(false);
+      expect(areDatesSameAsInitialDates(startDate, null, null, undefined))
+        .toBe(false);
+      expect(areDatesSameAsInitialDates(null, endDate, null, undefined))
+        .toBe(false);
+      expect(areDatesSameAsInitialDates(null, null, initialStart, undefined))
+        .toBe(false);
+      expect(areDatesSameAsInitialDates(startDate, endDate, null, initialEnd))
+        .toBe(false);
+    });
+
+    test('returns true when all params are the same', () => {
+      expect(areDatesSameAsInitialDates(startDate, endDate, initialStart, initialEnd))
+        .toBe(true);
+    });
+
+    test('returns false when not all params are same', () => {
+      expect(areDatesSameAsInitialDates(
+        startDate, endDate, moment('2024-04-22').toDate(), initialEnd))
+        .toBe(false);
+      expect(areDatesSameAsInitialDates(
+        startDate, endDate, initialStart, moment('2024-04-25').toDate()))
+        .toBe(false);
+    });
+  });
+});
diff --git a/app/shared/reservation-date/ReservationOvernightDate.spec.js b/app/shared/reservation-date/ReservationOvernightDate.spec.js
new file mode 100644
index 000000000..e80ae1203
--- /dev/null
+++ b/app/shared/reservation-date/ReservationOvernightDate.spec.js
@@ -0,0 +1,51 @@
+import React from 'react';
+
+import { shallowWithIntl } from 'utils/testUtils';
+import ReservationOvernightDate from './ReservationOvernightDate';
+
+describe('shared/reservation-date/ReservationOvernightDate', () => {
+  function getWrapper(extraProps) {
+    return shallowWithIntl(<ReservationOvernightDate {...extraProps} />);
+  }
+
+  let wrapper;
+
+  const beginDate = '2018-01-29T13:00:00+02:00';
+  const endDate = '2018-01-31T09:00:00+02:00';
+
+  beforeAll(() => {
+    wrapper = getWrapper({
+      beginDate,
+      endDate
+    });
+  });
+
+  test('renders a container div', () => {
+    const container = wrapper.find('div.reservation-date');
+    expect(container.length).toBe(1);
+  });
+
+  test('renders time texts', () => {
+    const texts = wrapper.find('p.reservation-date__time');
+    expect(texts.length).toBe(3);
+    expect(texts.at(0).text()).toBe('common.time.begin: 29.1.2018 13:00');
+    expect(texts.at(1).text()).toBe('common.time.end: 31.1.2018 09:00');
+    expect(texts.at(2).text()).toBe('common.time.duration: 1common.unit.time.day.short 20h');
+  });
+
+  test('renders time icons', () => {
+    const icons = wrapper.find('img.reservation-date__icon');
+    expect(icons.length).toBe(3);
+    expect(icons.at(0).prop('src')).toBe('test-file-stub');
+    expect(icons.at(0).prop('alt')).toBe('');
+    expect(icons.at(1).prop('src')).toBe('test-file-stub');
+    expect(icons.at(1).prop('alt')).toBe('');
+    expect(icons.at(2).prop('src')).toBe('test-file-stub');
+    expect(icons.at(2).prop('alt')).toBe('');
+  });
+
+  test('renders empty when start or end date missing', () => {
+    const emptyWrapper = getWrapper({});
+    expect(emptyWrapper.equals(<span />)).toBe(true);
+  });
+});