Add tests for month and year logic and improve coverage

Introduces new test suites for month and year logic helpers, covering keyboard navigation, disabled states, and focus management. Adds additional tests for edge cases in date utilities, click outside wrapper, shadow root, and exposes new helpers via the main entry point. Improves robustness and coverage of calendar and datepicker components.

Author: martijnrusschen

src/date_utils.ts

@@ -1090,6 +1090,7 @@ export function isTimeInDisabledRange(
   try {
     valid = !isWithinInterval(baseTime, { start: min, end: max });
   } catch (err) {
+    /* istanbul ignore next - date-fns historically threw on invalid intervals */
     valid = false;
   }
   return valid;

src/test/calendar_container.test.tsx

@@ -2,6 +2,7 @@ import { render } from "@testing-library/react";
 import React from "react";
 
 import CalendarContainer from "../calendar_container";
+import { CalendarContainer as CalendarContainerFromIndex } from "../index";
 
 describe("CalendarContainer", () => {
   it("renders with default props", () => {
@@ -18,6 +19,16 @@ describe("CalendarContainer", () => {
     expect(dialog?.textContent).toBe("Test Content");
   });
 
+  it("exposes CalendarContainer via the package entry point", () => {
+    const { container } = render(
+      <CalendarContainerFromIndex>
+        <div>Entry Content</div>
+      </CalendarContainerFromIndex>,
+    );
+
+    expect(container.querySelector('[role="dialog"]')).toBeTruthy();
+  });
+
   it("renders with showTimeSelectOnly prop", () => {
     const { container } = render(
       <CalendarContainer showTimeSelectOnly>

src/test/click_outside_wrapper.test.tsx

@@ -225,4 +225,58 @@ describe("ClickOutsideWrapper", () => {
     addEventListenerSpy.mockRestore();
     removeEventListenerSpy.mockRestore();
   });
+
+  it("falls back to event.target when composedPath does not return nodes", () => {
+    const addEventListenerSpy = jest.spyOn(document, "addEventListener");
+    render(
+      <ClickOutsideWrapper onClickOutside={onClickOutsideMock}>
+        <div>Inside</div>
+      </ClickOutsideWrapper>,
+    );
+
+    const handlerEntry = addEventListenerSpy.mock.calls.find(
+      ([type]) => type === "mousedown",
+    );
+    const handler = handlerEntry?.[1] as EventListener;
+
+    const outsideNode = document.createElement("div");
+    const mockEvent = {
+      composed: true,
+      composedPath: () => [{}],
+      target: outsideNode,
+    } as unknown as MouseEvent;
+
+    handler(mockEvent);
+
+    expect(onClickOutsideMock).toHaveBeenCalledTimes(1);
+    addEventListenerSpy.mockRestore();
+  });
+
+  it("does not treat non-HTMLElement targets as ignored elements", () => {
+    const addEventListenerSpy = jest.spyOn(document, "addEventListener");
+    render(
+      <ClickOutsideWrapper
+        onClickOutside={onClickOutsideMock}
+        ignoreClass="ignore-me"
+      >
+        <div>Inside</div>
+      </ClickOutsideWrapper>,
+    );
+
+    const handlerEntry = addEventListenerSpy.mock.calls.find(
+      ([type]) => type === "mousedown",
+    );
+    const handler = handlerEntry?.[1] as EventListener;
+
+    const textNode = document.createTextNode("outside");
+    const mockEvent = {
+      composed: false,
+      target: textNode,
+    } as unknown as MouseEvent;
+
+    handler(mockEvent);
+
+    expect(onClickOutsideMock).toHaveBeenCalledTimes(1);
+    addEventListenerSpy.mockRestore();
+  });
 });

src/test/date_utils_test.test.ts

@@ -1148,6 +1148,14 @@ describe("date_utils", () => {
 
       expect(isMonthInRange(startDate, endDate, 1, day)).toBe(false);
     });
+
+    it("should return false when the start year is after the end year", () => {
+      const day = newDate("2025-01-01");
+      const startDate = newDate("2026-01-01");
+      const endDate = newDate("2024-01-01");
+
+      expect(isMonthInRange(startDate, endDate, 1, day)).toBe(false);
+    });
   });
 
   describe("getStartOfYear", () => {
@@ -1190,6 +1198,14 @@ describe("date_utils", () => {
 
       expect(isQuarterInRange(startDate, endDate, 1, day)).toBe(false);
     });
+
+    it("should return false when the start year is after the end year", () => {
+      const day = newDate("2025-01-01");
+      const startDate = newDate("2026-01-01");
+      const endDate = newDate("2024-04-01");
+
+      expect(isQuarterInRange(startDate, endDate, 1, day)).toBe(false);
+    });
   });
 
   describe("isYearInRange", () => {
@@ -1214,6 +1230,12 @@ describe("date_utils", () => {
     it("should return false if range isn't passed", () => {
       expect(isYearInRange(2016)).toBe(false);
     });
+
+    it("should return false if provided dates are invalid", () => {
+      expect(
+        isYearInRange(2016, new Date("invalid"), new Date("invalid")),
+      ).toBe(false);
+    });
   });
 
   describe("getYearsPeriod", () => {

src/test/datepicker_test.test.tsx

@@ -26,7 +26,11 @@ import {
   subWeeks,
   subYears,
 } from "../date_utils";
-import DatePicker, { registerLocale } from "../index";
+import DatePicker, {
+  registerLocale,
+  setDefaultLocale,
+  getDefaultLocale,
+} from "../index";
 
 import CustomInput from "./helper_components/custom_input";
 import ShadowRoot from "./helper_components/shadow_root";
@@ -121,6 +125,73 @@ describe("DatePicker", () => {
     jest.resetAllMocks();
   });
 
+  it("exposes locale helpers via the main entry point", () => {
+    const originalLocale = getDefaultLocale();
+    try {
+      expect(getDefaultLocale()).toBe(originalLocale);
+      setDefaultLocale("en-GB");
+      expect(getDefaultLocale()).toBe("en-GB");
+    } finally {
+      setDefaultLocale(originalLocale);
+    }
+  });
+
+  it("does not trigger selection changes when readOnly", () => {
+    const onChange = jest.fn();
+    const { instance } = renderDatePickerWithRef({
+      readOnly: true,
+      onChange,
+    });
+
+    act(() => {
+      instance?.handleSelect(newDate("2024-05-01"));
+    });
+
+    expect(onChange).not.toHaveBeenCalled();
+  });
+
+  it("skips updating preSelection when readOnly", () => {
+    const selected = newDate("2024-01-01");
+    const { instance } = renderDatePickerWithRef({
+      readOnly: true,
+      selected,
+    });
+
+    const originalPreSelection = instance?.state.preSelection;
+
+    act(() => {
+      instance?.setPreSelection(newDate("2024-02-01"));
+    });
+
+    expect(instance?.state.preSelection).toBe(originalPreSelection);
+  });
+
+  it("short-circuits day key navigation when keyboard navigation is disabled", () => {
+    const onKeyDown = jest.fn();
+    const preSelection = newDate("2024-06-15");
+    const { instance } = renderDatePickerWithRef({
+      disabledKeyboardNavigation: true,
+      onKeyDown,
+      inline: true,
+      selected: preSelection,
+    });
+
+    act(() => {
+      instance?.setState({ preSelection });
+    });
+
+    act(() => {
+      instance?.onDayKeyDown({
+        key: "ArrowRight",
+        shiftKey: false,
+        preventDefault: jest.fn(),
+      } as unknown as React.KeyboardEvent<HTMLDivElement>);
+    });
+
+    expect(onKeyDown).toHaveBeenCalled();
+    expect(instance?.state.preSelection).toBe(preSelection);
+  });
+
   it("should retain the calendar open status when the document visibility change", () => {
     const { container } = render(<DatePicker />);
     const input = safeQuerySelector(container, "input");

src/test/month_logic.test.ts

@@ -0,0 +1,75 @@
+import type React from "react";
+import Month from "../month";
+import { KeyType, newDate } from "../date_utils";
+
+type MonthComponentProps = React.ComponentProps<typeof Month>;
+
+const buildProps = (
+  override: Partial<MonthComponentProps> = {},
+): MonthComponentProps =>
+  ({
+    day: newDate("2024-01-01"),
+    onDayClick: jest.fn(),
+    onDayMouseEnter: jest.fn(),
+    onMouseLeave: jest.fn(),
+    setPreSelection: jest.fn(),
+    preSelection: newDate("2024-01-01"),
+    showFourColumnMonthYearPicker: false,
+    showTwoColumnMonthYearPicker: false,
+    disabledKeyboardNavigation: false,
+    ...override,
+  }) as MonthComponentProps;
+
+describe("Month logic helpers", () => {
+  it("short-circuits keyboard navigation when there is no preSelection", () => {
+    const props = buildProps({ preSelection: undefined });
+    const instance = new Month(props);
+    const getVerticalOffsetSpy = jest.spyOn(instance, "getVerticalOffset");
+
+    instance.handleKeyboardNavigation(
+      {
+        preventDefault: jest.fn(),
+      } as unknown as React.KeyboardEvent<HTMLDivElement>,
+      KeyType.ArrowRight,
+      1,
+    );
+
+    expect(getVerticalOffsetSpy).not.toHaveBeenCalled();
+    expect(props.setPreSelection).not.toHaveBeenCalled();
+  });
+
+  it("prevents quarter navigation when the destination date is disabled", () => {
+    const props = buildProps();
+    const instance = new Month(props);
+    jest.spyOn(instance, "isDisabled").mockReturnValue(true);
+    jest.spyOn(instance, "isExcluded").mockReturnValue(false);
+
+    instance.handleQuarterNavigation(2, newDate("2024-04-01"));
+
+    expect(props.setPreSelection).not.toHaveBeenCalled();
+  });
+
+  it("does not handle quarter arrow keys without a preSelection value", () => {
+    const props = buildProps({ preSelection: undefined });
+    const instance = new Month(props);
+    const navigationSpy = jest.spyOn(instance, "handleQuarterNavigation");
+
+    instance.onQuarterKeyDown(
+      {
+        key: KeyType.ArrowRight,
+        preventDefault: jest.fn(),
+      } as unknown as React.KeyboardEvent<HTMLDivElement>,
+      2,
+    );
+
+    instance.onQuarterKeyDown(
+      {
+        key: KeyType.ArrowLeft,
+        preventDefault: jest.fn(),
+      } as unknown as React.KeyboardEvent<HTMLDivElement>,
+      2,
+    );
+
+    expect(navigationSpy).not.toHaveBeenCalled();
+  });
+});

src/test/shadow_root.test.tsx

@@ -75,4 +75,16 @@ describe("ShadowRoot", () => {
 
     expect(container.querySelector("div")).not.toBeNull();
   });
+
+  it("should avoid re-initializing when effect runs multiple times", () => {
+    const { container } = render(
+      <React.StrictMode>
+        <ShadowRoot>
+          <div>Strict Content</div>
+        </ShadowRoot>
+      </React.StrictMode>,
+    );
+
+    expect(container.querySelector("div")).not.toBeNull();
+  });
 });

src/test/test_utils.test.ts

@@ -1,7 +1,9 @@
+import { KeyType } from "../date_utils";
 import {
   SafeElementWrapper,
   safeQuerySelector,
   safeQuerySelectorAll,
+  getKey,
 } from "./test_utils";
 
 describe("test_utils", () => {
@@ -37,6 +39,12 @@ describe("test_utils", () => {
     });
   });
 
+  describe("getKey", () => {
+    it("should throw when key is not supported", () => {
+      expect(() => getKey("?" as KeyType)).toThrow("Unknown key");
+    });
+  });
+
   describe("safeQuerySelectorAll", () => {
     let container: HTMLElement;