@oslokommune/punkt-elements 14.0.2 → 14.0.3

package/src/components/datepicker/datepicker-utils.test.ts

@@ -0,0 +1,730 @@
+import { describe, it, expect, vi } from 'vitest'
+import {
+  valueUtils,
+  inputTypeUtils,
+  formUtils,
+  calendarUtils,
+  eventUtils,
+  cssUtils,
+  dateProcessingUtils,
+  keyboardUtils,
+} from './datepicker-utils'
+import { createRef } from 'lit/directives/ref.js'
+
+describe('datepicker-utils', () => {
+  describe('valueUtils', () => {
+    describe('normalizeNameForMultiple', () => {
+      it('should return null when name is null', () => {
+        expect(valueUtils.normalizeNameForMultiple(null, false, false)).toBe(null)
+        expect(valueUtils.normalizeNameForMultiple(null, true, false)).toBe(null)
+        expect(valueUtils.normalizeNameForMultiple(null, false, true)).toBe(null)
+      })
+
+      it('should add [] suffix for multiple inputs without []', () => {
+        expect(valueUtils.normalizeNameForMultiple('dates', true, false)).toBe('dates[]')
+      })
+
+      it('should add [] suffix for range inputs without []', () => {
+        expect(valueUtils.normalizeNameForMultiple('daterange', false, true)).toBe('daterange[]')
+      })
+
+      it('should not add [] suffix when already present', () => {
+        expect(valueUtils.normalizeNameForMultiple('dates[]', true, false)).toBe('dates[]')
+        expect(valueUtils.normalizeNameForMultiple('range[]', false, true)).toBe('range[]')
+      })
+
+      it('should not modify name for single inputs', () => {
+        expect(valueUtils.normalizeNameForMultiple('singledate', false, false)).toBe('singledate')
+      })
+    })
+
+    describe('validateRangeOrder', () => {
+      it('should return true for incomplete ranges', () => {
+        expect(valueUtils.validateRangeOrder([])).toBe(true)
+        expect(valueUtils.validateRangeOrder(['2024-01-01'])).toBe(true)
+      })
+
+      it('should return true for valid date ranges', () => {
+        expect(valueUtils.validateRangeOrder(['2024-01-01', '2024-01-31'])).toBe(true)
+        expect(valueUtils.validateRangeOrder(['2024-01-01', '2024-01-01'])).toBe(true)
+      })
+
+      it('should return false for invalid date ranges', () => {
+        expect(valueUtils.validateRangeOrder(['2024-01-31', '2024-01-01'])).toBe(false)
+      })
+    })
+
+    describe('sortDates', () => {
+      it('should sort dates chronologically', () => {
+        const dates = ['2024-03-15', '2024-01-10', '2024-02-20']
+        const sorted = valueUtils.sortDates(dates)
+        expect(sorted).toEqual(['2024-01-10', '2024-02-20', '2024-03-15'])
+      })
+
+      it('should handle empty array', () => {
+        expect(valueUtils.sortDates([])).toEqual([])
+      })
+    })
+
+    describe('filterSelectableDates', () => {
+      it('should filter dates outside min/max range', () => {
+        const dates = ['2024-01-01', '2024-01-15', '2024-01-31']
+        const filtered = valueUtils.filterSelectableDates(dates, '2024-01-10', '2024-01-20')
+        expect(filtered).toEqual(['2024-01-15'])
+      })
+
+      it('should filter excluded dates', () => {
+        const dates = ['2024-01-01', '2024-01-02', '2024-01-03']
+        const filtered = valueUtils.filterSelectableDates(
+          dates,
+          null,
+          null,
+          ['2024-01-02'],
+          undefined,
+        )
+        expect(filtered).toEqual(['2024-01-01', '2024-01-03'])
+      })
+
+      it('should filter excluded weekdays', () => {
+        const dates = ['2024-01-01', '2024-01-06', '2024-01-07'] // Mon, Sat, Sun
+        const filtered = valueUtils.filterSelectableDates(dates, null, null, undefined, ['0', '6']) // Exclude weekends
+        expect(filtered).toEqual(['2024-01-01'])
+      })
+    })
+  })
+
+  describe('inputTypeUtils', () => {
+    describe('getInputType', () => {
+      it('should return "text" for iOS devices', () => {
+        // Mock isIOS to return true
+        vi.mock('shared-utils/device-utils', () => ({
+          isIOS: () => true,
+        }))
+        // Note: This test is limited by how vitest handles module mocking
+        // In a real scenario, you'd need proper mocking setup
+      })
+
+      it('should return "date" for non-iOS devices', () => {
+        // The function returns based on isIOS() which is mocked elsewhere
+        const type = inputTypeUtils.getInputType()
+        expect(['text', 'date']).toContain(type)
+      })
+    })
+  })
+
+  describe('formUtils', () => {
+    describe('submitForm', () => {
+      it('should call requestSubmit on the form if available', () => {
+        const mockForm = { requestSubmit: vi.fn() }
+        const element = {
+          internals: { form: mockForm },
+        } as any
+
+        formUtils.submitForm(element)
+        expect(mockForm.requestSubmit).toHaveBeenCalledOnce()
+      })
+
+      it('should not throw if form is not available', () => {
+        const element = {} as any
+        expect(() => formUtils.submitForm(element)).not.toThrow()
+      })
+    })
+
+    describe('submitFormOrFallback', () => {
+      it('should submit form if internals has form', () => {
+        const mockForm = { requestSubmit: vi.fn() }
+        const fallback = vi.fn()
+        const internals = { form: mockForm }
+
+        formUtils.submitFormOrFallback(internals, fallback)
+        expect(mockForm.requestSubmit).toHaveBeenCalledOnce()
+        expect(fallback).not.toHaveBeenCalled()
+      })
+
+      it('should call fallback if no form available', () => {
+        const fallback = vi.fn()
+        formUtils.submitFormOrFallback(null, fallback)
+        expect(fallback).toHaveBeenCalledOnce()
+      })
+
+      it('should call fallback if internals has no form', () => {
+        const fallback = vi.fn()
+        const internals = {}
+        formUtils.submitFormOrFallback(internals, fallback)
+        expect(fallback).toHaveBeenCalledOnce()
+      })
+    })
+
+    describe('validateDateInput', () => {
+      it('should return early if input has no value', () => {
+        const input = { value: '' } as HTMLInputElement
+        const internals = { setValidity: vi.fn() }
+        formUtils.validateDateInput(input, internals)
+        expect(internals.setValidity).not.toHaveBeenCalled()
+      })
+
+      it('should set rangeUnderflow validity when value is below minimum', () => {
+        const input = { value: '2024-01-01' } as HTMLInputElement
+        const internals = { setValidity: vi.fn() }
+        const strings = { forms: { messages: { rangeUnderflow: 'Too early' } } }
+
+        formUtils.validateDateInput(input, internals, '2024-01-10', null, strings)
+        expect(internals.setValidity).toHaveBeenCalledWith(
+          { rangeUnderflow: true },
+          'Too early',
+          input,
+        )
+      })
+
+      it('should set rangeOverflow validity when value is above maximum', () => {
+        const input = { value: '2024-01-31' } as HTMLInputElement
+        const internals = { setValidity: vi.fn() }
+        const strings = { forms: { messages: { rangeOverflow: 'Too late' } } }
+
+        formUtils.validateDateInput(input, internals, null, '2024-01-20', strings)
+        expect(internals.setValidity).toHaveBeenCalledWith(
+          { rangeOverflow: true },
+          'Too late',
+          input,
+        )
+      })
+
+      it('should use default messages when strings not provided', () => {
+        const input = { value: '2024-01-01' } as HTMLInputElement
+        const internals = { setValidity: vi.fn() }
+
+        formUtils.validateDateInput(input, internals, '2024-01-10', null)
+        expect(internals.setValidity).toHaveBeenCalledWith(
+          { rangeUnderflow: true },
+          'Value is below minimum',
+          input,
+        )
+      })
+    })
+  })
+
+  describe('calendarUtils', () => {
+    describe('addToSelected', () => {
+      it('should return early if target has no value', () => {
+        const event = { target: { value: '' } } as any
+        const calendarRef = createRef()
+        calendarUtils.addToSelected(event, calendarRef as any)
+        // Should not throw
+      })
+
+      it('should clear input value after processing', () => {
+        const mockCalendar = { handleDateSelect: vi.fn() }
+        const target = { value: '2024-01-15' }
+        const event = { target } as any
+        const calendarRef = { value: mockCalendar } as any
+
+        calendarUtils.addToSelected(event, calendarRef)
+        expect(target.value).toBe('')
+      })
+
+      it('should call handleDateSelect with valid date', () => {
+        const mockCalendar = { handleDateSelect: vi.fn() }
+        const target = { value: '2024-01-15' }
+        const event = { target } as any
+        const calendarRef = { value: mockCalendar } as any
+
+        calendarUtils.addToSelected(event, calendarRef)
+        expect(mockCalendar.handleDateSelect).toHaveBeenCalled()
+      })
+
+      it('should respect min/max constraints', () => {
+        const mockCalendar = { handleDateSelect: vi.fn() }
+        const target = { value: '2024-01-05' }
+        const event = { target } as any
+        const calendarRef = { value: mockCalendar } as any
+
+        calendarUtils.addToSelected(event, calendarRef, '2024-01-10', '2024-01-20')
+        expect(mockCalendar.handleDateSelect).not.toHaveBeenCalled()
+        expect(target.value).toBe('')
+      })
+    })
+
+    describe('handleCalendarPosition', () => {
+      it('should return early if refs are not available', () => {
+        const popupRef = createRef()
+        const inputRef = createRef()
+        expect(() => calendarUtils.handleCalendarPosition(popupRef as any, inputRef as any)).not.toThrow()
+      })
+
+      it('should position calendar below input by default', () => {
+        const mockPopup = { style: { top: '' }, getBoundingClientRect: () => ({ height: 300 }) }
+        const mockInput = {
+          getBoundingClientRect: () => ({ height: 40, top: 100 }),
+          parentElement: null,
+        }
+        const popupRef = { value: mockPopup } as any
+        const inputRef = { value: mockInput } as any
+
+        calendarUtils.handleCalendarPosition(popupRef, inputRef)
+        expect(mockPopup.style.top).toBe('100%')
+      })
+
+      it('should position calendar above input if not enough space below', () => {
+        const mockPopup = { style: { top: '' }, getBoundingClientRect: () => ({ height: 400 }) }
+        const mockInput = {
+          getBoundingClientRect: () => ({ height: 40, top: window.innerHeight - 100 }),
+          parentElement: null,
+        }
+        const popupRef = { value: mockPopup } as any
+        const inputRef = { value: mockInput } as any
+
+        calendarUtils.handleCalendarPosition(popupRef, inputRef)
+        expect(mockPopup.style.top).toContain('calc(100%')
+        expect(mockPopup.style.top).toContain('px')
+      })
+
+      it('should account for counter when hasCounter is true', () => {
+        const mockPopup = { style: { top: '' }, getBoundingClientRect: () => ({ height: 300 }) }
+        const mockInput = {
+          getBoundingClientRect: () => ({ height: 40, top: 100 }),
+          parentElement: null,
+        }
+        const popupRef = { value: mockPopup } as any
+        const inputRef = { value: mockInput } as any
+
+        calendarUtils.handleCalendarPosition(popupRef, inputRef, true)
+        expect(mockPopup.style.top).toBe('calc(100% - 30px)')
+      })
+    })
+  })
+
+  describe('eventUtils', () => {
+    describe('createDocumentClickListener', () => {
+      it('should return a function', () => {
+        const listener = eventUtils.createDocumentClickListener(
+          createRef() as any,
+          null,
+          createRef() as any,
+          () => true,
+          vi.fn(),
+          vi.fn(),
+        )
+        expect(typeof listener).toBe('function')
+      })
+
+      it('should call onBlur and hideCalendar when clicking outside', () => {
+        const onBlur = vi.fn()
+        const hideCalendar = vi.fn()
+        const inputRef = { value: { contains: () => false } } as any
+        const btnRef = { value: { contains: () => false } } as any
+
+        const listener = eventUtils.createDocumentClickListener(
+          inputRef,
+          null,
+          btnRef,
+          () => true,
+          onBlur,
+          hideCalendar,
+        )
+
+        const event = {
+          target: document.createElement('div'),
+        } as any
+
+        listener(event)
+        expect(onBlur).toHaveBeenCalledOnce()
+        expect(hideCalendar).toHaveBeenCalledOnce()
+      })
+
+      it('should not call handlers when clicking inside input', () => {
+        const onBlur = vi.fn()
+        const hideCalendar = vi.fn()
+        const inputRef = { value: { contains: () => true } } as any
+        const btnRef = { value: { contains: () => false } } as any
+
+        const listener = eventUtils.createDocumentClickListener(
+          inputRef,
+          null,
+          btnRef,
+          () => true,
+          onBlur,
+          hideCalendar,
+        )
+
+        const event = {
+          target: document.createElement('div'),
+        } as any
+
+        listener(event)
+        expect(onBlur).not.toHaveBeenCalled()
+        expect(hideCalendar).not.toHaveBeenCalled()
+      })
+    })
+
+    describe('createDocumentKeydownListener', () => {
+      it('should return a function', () => {
+        const listener = eventUtils.createDocumentKeydownListener(() => true, vi.fn())
+        expect(typeof listener).toBe('function')
+      })
+
+      it('should call hideCalendar on Escape key', () => {
+        const hideCalendar = vi.fn()
+        const listener = eventUtils.createDocumentKeydownListener(() => true, hideCalendar)
+
+        const event = { key: 'Escape' } as KeyboardEvent
+        listener(event)
+        expect(hideCalendar).toHaveBeenCalledOnce()
+      })
+
+      it('should not call hideCalendar if calendar is not open', () => {
+        const hideCalendar = vi.fn()
+        const listener = eventUtils.createDocumentKeydownListener(() => false, hideCalendar)
+
+        const event = { key: 'Escape' } as KeyboardEvent
+        listener(event)
+        expect(hideCalendar).not.toHaveBeenCalled()
+      })
+
+      it('should not call hideCalendar on other keys', () => {
+        const hideCalendar = vi.fn()
+        const listener = eventUtils.createDocumentKeydownListener(() => true, hideCalendar)
+
+        const event = { key: 'Enter' } as KeyboardEvent
+        listener(event)
+        expect(hideCalendar).not.toHaveBeenCalled()
+      })
+    })
+
+    describe('handleFocusOut', () => {
+      it('should call onBlur and hideCalendar when focus leaves element', () => {
+        const onBlur = vi.fn()
+        const hideCalendar = vi.fn()
+        const element = { contains: () => false } as any
+        const event = { target: document.createElement('div') } as any
+
+        eventUtils.handleFocusOut(event, element, onBlur, hideCalendar)
+        expect(onBlur).toHaveBeenCalledOnce()
+        expect(hideCalendar).toHaveBeenCalledOnce()
+      })
+
+      it('should not call handlers when focus stays within element', () => {
+        const onBlur = vi.fn()
+        const hideCalendar = vi.fn()
+        const element = { contains: () => true } as any
+        const event = { target: document.createElement('div') } as any
+
+        eventUtils.handleFocusOut(event, element, onBlur, hideCalendar)
+        expect(onBlur).not.toHaveBeenCalled()
+        expect(hideCalendar).not.toHaveBeenCalled()
+      })
+    })
+  })
+
+  describe('cssUtils', () => {
+    describe('getInputClasses', () => {
+      it('should return base classes', () => {
+        const classes = cssUtils.getInputClasses(false, false, false, false)
+        expect(classes['pkt-input']).toBe(true)
+        expect(classes['pkt-datepicker__input']).toBe(true)
+      })
+
+      it('should include fullwidth class when fullwidth is true', () => {
+        const classes = cssUtils.getInputClasses(true, false, false, false)
+        expect(classes['pkt-input--fullwidth']).toBe(true)
+      })
+
+      it('should include hasrangelabels class when showRangeLabels is true', () => {
+        const classes = cssUtils.getInputClasses(false, true, false, false)
+        expect(classes['pkt-datepicker--hasrangelabels']).toBe(true)
+      })
+
+      it('should include multiple class when multiple is true', () => {
+        const classes = cssUtils.getInputClasses(false, false, true, false)
+        expect(classes['pkt-datepicker--multiple']).toBe(true)
+      })
+
+      it('should include range class when range is true', () => {
+        const classes = cssUtils.getInputClasses(false, false, false, true)
+        expect(classes['pkt-datepicker--range']).toBe(true)
+      })
+
+      it('should include ios-readonly-hack when readonly is false and inputType is text', () => {
+        const classes = cssUtils.getInputClasses(false, false, false, false, false, 'text')
+        expect(classes['ios-readonly-hack']).toBe(true)
+      })
+    })
+
+    describe('getButtonClasses', () => {
+      it('should return button classes', () => {
+        const classes = cssUtils.getButtonClasses()
+        expect(classes['pkt-input-icon']).toBe(true)
+        expect(classes['pkt-btn']).toBe(true)
+        expect(classes['pkt-btn--icon-only']).toBe(true)
+        expect(classes['pkt-btn--tertiary']).toBe(true)
+        expect(classes['pkt-datepicker__calendar-button']).toBe(true)
+      })
+    })
+
+    describe('getRangeLabelClasses', () => {
+      it('should return correct classes when showRangeLabels is true', () => {
+        const classes = cssUtils.getRangeLabelClasses(true)
+        expect(classes['pkt-input-prefix']).toBe(true)
+        expect(classes['pkt-hide']).toBe(false)
+      })
+
+      it('should return correct classes when showRangeLabels is false', () => {
+        const classes = cssUtils.getRangeLabelClasses(false)
+        expect(classes['pkt-input-prefix']).toBe(false)
+        expect(classes['pkt-hide']).toBe(true)
+      })
+    })
+  })
+
+  describe('dateProcessingUtils', () => {
+    describe('processDateSelection', () => {
+      it('should return first date for single selection', () => {
+        const result = dateProcessingUtils.processDateSelection(['2024-01-15'], false, false)
+        expect(result).toBe('2024-01-15')
+      })
+
+      it('should return empty string when no dates for single selection', () => {
+        const result = dateProcessingUtils.processDateSelection([], false, false)
+        expect(result).toBe('')
+      })
+
+      it('should return comma-separated dates for multiple selection', () => {
+        const result = dateProcessingUtils.processDateSelection(
+          ['2024-01-15', '2024-01-20'],
+          true,
+          false,
+        )
+        expect(result).toBe('2024-01-15,2024-01-20')
+      })
+
+      it('should return comma-separated dates for range selection', () => {
+        const result = dateProcessingUtils.processDateSelection(
+          ['2024-01-15', '2024-01-20'],
+          false,
+          true,
+        )
+        expect(result).toBe('2024-01-15,2024-01-20')
+      })
+    })
+
+    describe('updateInputValues', () => {
+      it('should return early if inputRef has no value', () => {
+        const inputRef = { value: null } as any
+        expect(() =>
+          dateProcessingUtils.updateInputValues(inputRef, null, [], false, false, vi.fn()),
+        ).not.toThrow()
+      })
+
+      it('should update both inputs for range', () => {
+        const input = { value: '' } as any
+        const inputTo = { value: '' } as any
+        const inputRef = { value: input } as any
+        const inputRefTo = { value: inputTo } as any
+        const manageValidity = vi.fn()
+
+        dateProcessingUtils.updateInputValues(
+          inputRef,
+          inputRefTo,
+          ['2024-01-15', '2024-01-20'],
+          true,
+          false,
+          manageValidity,
+        )
+
+        expect(input.value).toBe('2024-01-15')
+        expect(inputTo.value).toBe('2024-01-20')
+        expect(manageValidity).toHaveBeenCalledTimes(2)
+      })
+
+      it('should update single input for non-multiple, non-range', () => {
+        const input = { value: '' } as any
+        const inputRef = { value: input } as any
+        const manageValidity = vi.fn()
+
+        dateProcessingUtils.updateInputValues(
+          inputRef,
+          null,
+          ['2024-01-15'],
+          false,
+          false,
+          manageValidity,
+        )
+
+        expect(input.value).toBe('2024-01-15')
+        expect(manageValidity).toHaveBeenCalledOnce()
+      })
+
+      it('should not update input for multiple selection', () => {
+        const input = { value: 'initial' } as any
+        const inputRef = { value: input } as any
+        const manageValidity = vi.fn()
+
+        dateProcessingUtils.updateInputValues(
+          inputRef,
+          null,
+          ['2024-01-15'],
+          false,
+          true,
+          manageValidity,
+        )
+
+        expect(input.value).toBe('initial')
+        expect(manageValidity).not.toHaveBeenCalled()
+      })
+    })
+
+    describe('processRangeBlur', () => {
+      it('should call manageValidity and handleDateSelect when target has value', () => {
+        const target = { value: '2024-01-15' } as any
+        const event = { target } as any
+        const mockCalendar = { handleDateSelect: vi.fn() }
+        const calendarRef = { value: mockCalendar } as any
+        const clearInputValue = vi.fn()
+        const manageValidity = vi.fn()
+
+        dateProcessingUtils.processRangeBlur(
+          event,
+          ['2024-01-10', '2024-01-20'],
+          calendarRef,
+          clearInputValue,
+          manageValidity,
+        )
+
+        expect(manageValidity).toHaveBeenCalledWith(target)
+        expect(clearInputValue).not.toHaveBeenCalled()
+        expect(mockCalendar.handleDateSelect).toHaveBeenCalled()
+      })
+
+      it('should clear input value when target is empty but values[0] exists', () => {
+        const target = { value: '' } as any
+        const event = { target } as any
+        const mockCalendar = { handleDateSelect: vi.fn() }
+        const calendarRef = { value: mockCalendar } as any
+        const clearInputValue = vi.fn()
+        const manageValidity = vi.fn()
+
+        dateProcessingUtils.processRangeBlur(
+          event,
+          ['2024-01-10'],
+          calendarRef,
+          clearInputValue,
+          manageValidity,
+        )
+
+        expect(clearInputValue).toHaveBeenCalled()
+        expect(manageValidity).not.toHaveBeenCalled()
+        expect(mockCalendar.handleDateSelect).not.toHaveBeenCalled()
+      })
+    })
+  })
+
+  describe('keyboardUtils', () => {
+    describe('handleInputKeydown', () => {
+      it('should call toggleCalendar on Space key', () => {
+        const toggleCalendar = vi.fn()
+        const event = { key: ' ', preventDefault: vi.fn() } as any
+
+        keyboardUtils.handleInputKeydown(event, toggleCalendar)
+        expect(event.preventDefault).toHaveBeenCalled()
+        expect(toggleCalendar).toHaveBeenCalledWith(event)
+      })
+
+      it('should call submitForm on Enter key when provided', () => {
+        const toggleCalendar = vi.fn()
+        const submitForm = vi.fn()
+        const event = { key: 'Enter', preventDefault: vi.fn() } as any
+
+        keyboardUtils.handleInputKeydown(event, toggleCalendar, submitForm)
+        expect(event.preventDefault).toHaveBeenCalled()
+        expect(submitForm).toHaveBeenCalled()
+        expect(toggleCalendar).not.toHaveBeenCalled()
+      })
+
+      it('should call focusNextInput on Enter when submitForm not provided', () => {
+        const toggleCalendar = vi.fn()
+        const focusNextInput = vi.fn()
+        const event = { key: 'Enter', preventDefault: vi.fn() } as any
+
+        keyboardUtils.handleInputKeydown(event, toggleCalendar, undefined, focusNextInput)
+        expect(event.preventDefault).toHaveBeenCalled()
+        expect(focusNextInput).toHaveBeenCalled()
+      })
+
+      it('should call blurInput on Enter when neither submitForm nor focusNextInput provided', () => {
+        const toggleCalendar = vi.fn()
+        const blurInput = vi.fn()
+        const event = { key: 'Enter', preventDefault: vi.fn() } as any
+
+        keyboardUtils.handleInputKeydown(
+          event,
+          toggleCalendar,
+          undefined,
+          undefined,
+          blurInput,
+        )
+        expect(event.preventDefault).toHaveBeenCalled()
+        expect(blurInput).toHaveBeenCalled()
+      })
+
+      it('should call commaHandler on comma key when provided', () => {
+        const toggleCalendar = vi.fn()
+        const commaHandler = vi.fn()
+        const event = { key: ',', preventDefault: vi.fn() } as any
+
+        keyboardUtils.handleInputKeydown(
+          event,
+          toggleCalendar,
+          undefined,
+          undefined,
+          undefined,
+          commaHandler,
+        )
+        expect(event.preventDefault).toHaveBeenCalled()
+        expect(commaHandler).toHaveBeenCalledWith(event)
+      })
+
+      it('should call blurInput on comma key when commaHandler not provided', () => {
+        const toggleCalendar = vi.fn()
+        const blurInput = vi.fn()
+        const event = { key: ',', preventDefault: vi.fn() } as any
+
+        keyboardUtils.handleInputKeydown(
+          event,
+          toggleCalendar,
+          undefined,
+          undefined,
+          blurInput,
+        )
+        expect(event.preventDefault).toHaveBeenCalled()
+        expect(blurInput).toHaveBeenCalled()
+      })
+    })
+
+    describe('handleButtonKeydown', () => {
+      it('should call toggleCalendar on Enter key', () => {
+        const toggleCalendar = vi.fn()
+        const event = { key: 'Enter', preventDefault: vi.fn() } as any
+
+        keyboardUtils.handleButtonKeydown(event, toggleCalendar)
+        expect(event.preventDefault).toHaveBeenCalled()
+        expect(toggleCalendar).toHaveBeenCalledWith(event)
+      })
+
+      it('should call toggleCalendar on Space key', () => {
+        const toggleCalendar = vi.fn()
+        const event = { key: ' ', preventDefault: vi.fn() } as any
+
+        keyboardUtils.handleButtonKeydown(event, toggleCalendar)
+        expect(event.preventDefault).toHaveBeenCalled()
+        expect(toggleCalendar).toHaveBeenCalledWith(event)
+      })
+
+      it('should not call toggleCalendar on other keys', () => {
+        const toggleCalendar = vi.fn()
+        const event = { key: 'a', preventDefault: vi.fn() } as any
+
+        keyboardUtils.handleButtonKeydown(event, toggleCalendar)
+        expect(toggleCalendar).not.toHaveBeenCalled()
+      })
+    })
+  })
+})