@cnamts/synapse 1.0.25 → 1.0.27

package/src/components/Tables/common/filters/DateFilter.vue

@@ -2,7 +2,7 @@
 	import { computed } from 'vue'
 	import type { FilterOption, TableColumnHeader } from '../types'
 	import DatePicker from '@/components/DatePicker/CalendarMode/DatePicker.vue'
-	import type { DateValue } from '@/composables/date/useDateInitializationDayjs'
+	import type { DateModelValue } from '@/composables/date/useDateInitializationDayjs'
 	import { useDateFormat } from '@/composables/date/useDateFormatDayjs'
 	const { parseDate } = useDateFormat()
 
@@ -16,7 +16,7 @@
 			default: () => [],
 		},
 		filterValue: {
-			type: [String, Date, Object, null] as unknown as () => DateValue,
+			type: [String, Date, Object, null] as unknown as () => DateModelValue,
 			default: null,
 		},
 		inputConfig: {

package/src/components/Tables/common/filters/logics/tests/NumberFilterLogic.spec.ts

@@ -0,0 +1,176 @@
+import { describe, it, expect } from 'vitest'
+import filter from '../number'
+
+describe('Number filter logic', () => {
+	describe('itemValue non-number', () => {
+		it('retourne false si itemValue est une string', () => {
+			expect(filter('42', 42)).toBe(false)
+		})
+
+		it('retourne false si itemValue est null', () => {
+			expect(filter(null, 42)).toBe(false)
+		})
+
+		it('retourne false si itemValue est undefined', () => {
+			expect(filter(undefined, 42)).toBe(false)
+		})
+
+		it('retourne false si itemValue est un boolean', () => {
+			expect(filter(true, 1)).toBe(false)
+		})
+	})
+
+	describe('filterValue numérique (exact match)', () => {
+		it('retourne true pour une valeur égale', () => {
+			expect(filter(42, 42)).toBe(true)
+		})
+
+		it('retourne false pour une valeur différente', () => {
+			expect(filter(42, 43)).toBe(false)
+		})
+
+		it('retourne true pour 0 === 0', () => {
+			expect(filter(0, 0)).toBe(true)
+		})
+
+		it('retourne false pour 0 !== 1', () => {
+			expect(filter(0, 1)).toBe(false)
+		})
+
+		it('retourne true pour des négatifs égaux', () => {
+			expect(filter(-5, -5)).toBe(true)
+		})
+	})
+
+	describe('filterValue string sans opérateur', () => {
+		it('retourne true pour correspondance exacte via string', () => {
+			expect(filter(42, '42')).toBe(true)
+		})
+
+		it('retourne true pour string avec virgule décimale', () => {
+			expect(filter(3.14, '3,14')).toBe(true)
+		})
+
+		it('retourne true pour string avec point décimal', () => {
+			expect(filter(3.14, '3.14')).toBe(true)
+		})
+
+		it('retourne false pour une string non numérique', () => {
+			expect(filter(42, 'abc')).toBe(false)
+		})
+
+		it('retourne false si la valeur ne correspond pas', () => {
+			expect(filter(42, '43')).toBe(false)
+		})
+	})
+
+	describe('opérateur =', () => {
+		it('retourne true pour =42 avec itemValue 42', () => {
+			expect(filter(42, '=42')).toBe(true)
+		})
+
+		it('retourne false pour =42 avec itemValue 43', () => {
+			expect(filter(43, '=42')).toBe(false)
+		})
+
+		it('retourne false si la valeur après = est non numérique', () => {
+			expect(filter(42, '=abc')).toBe(false)
+		})
+	})
+
+	describe('opérateur <>', () => {
+		it('retourne true pour <>42 avec itemValue 43', () => {
+			expect(filter(43, '<>42')).toBe(true)
+		})
+
+		it('retourne false pour <>42 avec itemValue 42', () => {
+			expect(filter(42, '<>42')).toBe(false)
+		})
+	})
+
+	describe('opérateur <', () => {
+		it('retourne true si itemValue < filterValue', () => {
+			expect(filter(10, '<20')).toBe(true)
+		})
+
+		it('retourne false si itemValue === filterValue', () => {
+			expect(filter(20, '<20')).toBe(false)
+		})
+
+		it('retourne false si itemValue > filterValue', () => {
+			expect(filter(30, '<20')).toBe(false)
+		})
+	})
+
+	describe('opérateur <=', () => {
+		it('retourne true si itemValue < filterValue', () => {
+			expect(filter(10, '<=20')).toBe(true)
+		})
+
+		it('retourne true si itemValue === filterValue', () => {
+			expect(filter(20, '<=20')).toBe(true)
+		})
+
+		it('retourne false si itemValue > filterValue', () => {
+			expect(filter(30, '<=20')).toBe(false)
+		})
+	})
+
+	describe('opérateur >', () => {
+		it('retourne true si itemValue > filterValue', () => {
+			expect(filter(30, '>20')).toBe(true)
+		})
+
+		it('retourne false si itemValue === filterValue', () => {
+			expect(filter(20, '>20')).toBe(false)
+		})
+
+		it('retourne false si itemValue < filterValue', () => {
+			expect(filter(10, '>20')).toBe(false)
+		})
+	})
+
+	describe('opérateur >=', () => {
+		it('retourne true si itemValue > filterValue', () => {
+			expect(filter(30, '>=20')).toBe(true)
+		})
+
+		it('retourne true si itemValue === filterValue', () => {
+			expect(filter(20, '>=20')).toBe(true)
+		})
+
+		it('retourne false si itemValue < filterValue', () => {
+			expect(filter(10, '>=20')).toBe(false)
+		})
+	})
+
+	describe('virgule comme séparateur décimal dans opérateurs', () => {
+		it('retourne true pour >=3,5 avec itemValue 4', () => {
+			expect(filter(4, '>=3,5')).toBe(true)
+		})
+
+		it('retourne true pour <=3,5 avec itemValue 3', () => {
+			expect(filter(3, '<=3,5')).toBe(true)
+		})
+
+		it('retourne true pour =3,14 avec itemValue 3.14', () => {
+			expect(filter(3.14, '=3,14')).toBe(true)
+		})
+	})
+
+	describe('valeur NaN après opérateur', () => {
+		it('retourne false si la valeur après < est non numérique', () => {
+			expect(filter(42, '<abc')).toBe(false)
+		})
+
+		it('retourne false si la valeur après > est non numérique', () => {
+			expect(filter(42, '>abc')).toBe(false)
+		})
+	})
+
+	describe('fallback String.includes pour filterValue autre', () => {
+		it('retourne true si String(itemValue).includes(String(filterValue)) pour filterValue boolean', () => {
+			expect(filter(42, true as unknown as string)).toBe(false)
+		})
+	})
+})

package/src/components/Tables/common/filters/logics/tests/SelectFilterLogic.spec.ts

@@ -0,0 +1,111 @@
+import { describe, it, expect } from 'vitest'
+import filter from '../select'
+
+describe('Select filter logic', () => {
+	describe('filterValue scalaire (valeur unique)', () => {
+		it('retourne true pour une correspondance exacte de string', () => {
+			expect(filter('foo', 'foo')).toBe(true)
+		})
+
+		it('retourne false pour une non-correspondance de string', () => {
+			expect(filter('foo', 'bar')).toBe(false)
+		})
+
+		it('retourne true pour une correspondance exacte de number', () => {
+			expect(filter(42, 42)).toBe(true)
+		})
+
+		it('retourne false pour une non-correspondance de number', () => {
+			expect(filter(42, 43)).toBe(false)
+		})
+
+		it('retourne true pour null === null', () => {
+			expect(filter(null, null)).toBe(true)
+		})
+
+		it('retourne false pour null !== "foo"', () => {
+			expect(filter(null, 'foo')).toBe(false)
+		})
+
+		it('retourne true pour boolean true === true', () => {
+			expect(filter(true, true)).toBe(true)
+		})
+
+		it('retourne false pour boolean true !== false', () => {
+			expect(filter(true, false)).toBe(false)
+		})
+	})
+
+	describe('filterValue objet (comparaison JSON)', () => {
+		it('retourne true pour deux objets identiques', () => {
+			expect(filter({ id: 1, label: 'A' }, { id: 1, label: 'A' })).toBe(true)
+		})
+
+		it('retourne false pour deux objets différents', () => {
+			expect(filter({ id: 1, label: 'A' }, { id: 2, label: 'B' })).toBe(false)
+		})
+
+		it('retourne false si itemValue est une string et filterValue un objet', () => {
+			expect(filter('foo', { id: 1 })).toBe(false)
+		})
+
+		it('retourne true pour deux objets imbriqués identiques', () => {
+			const obj = { a: { b: 1 } }
+			expect(filter({ a: { b: 1 } }, obj)).toBe(true)
+		})
+	})
+
+	describe('filterValue tableau — itemValue scalaire', () => {
+		it('retourne true si itemValue est dans le tableau', () => {
+			expect(filter('foo', ['foo', 'bar'])).toBe(true)
+		})
+
+		it('retourne false si itemValue n\'est pas dans le tableau', () => {
+			expect(filter('baz', ['foo', 'bar'])).toBe(false)
+		})
+
+		it('retourne true pour un number inclus dans le tableau', () => {
+			expect(filter(2, [1, 2, 3])).toBe(true)
+		})
+
+		it('retourne false pour un number non inclus dans le tableau', () => {
+			expect(filter(5, [1, 2, 3])).toBe(false)
+		})
+
+		it('retourne false pour un tableau filterValue vide', () => {
+			expect(filter('foo', [])).toBe(false)
+		})
+	})
+
+	describe('filterValue tableau — itemValue tableau', () => {
+		it('retourne true si au moins un élément commun (primitifs)', () => {
+			expect(filter(['Vue', 'React'], ['Vue', 'Angular'])).toBe(true)
+		})
+
+		it('retourne false si aucun élément commun (primitifs)', () => {
+			expect(filter(['Svelte', 'Angular'], ['Vue', 'React'])).toBe(false)
+		})
+
+		it('retourne true si au moins un objet commun (comparaison JSON)', () => {
+			expect(filter(
+				[{ id: 1 }, { id: 2 }],
+				[{ id: 2 }, { id: 3 }],
+			)).toBe(true)
+		})
+
+		it('retourne false si aucun objet commun (comparaison JSON)', () => {
+			expect(filter(
+				[{ id: 1 }],
+				[{ id: 2 }],
+			)).toBe(false)
+		})
+
+		it('retourne false si itemValue est tableau vide', () => {
+			expect(filter([], ['foo'])).toBe(false)
+		})
+
+		it('retourne false si filterValue est tableau vide', () => {
+			expect(filter(['foo'], [])).toBe(false)
+		})
+	})
+})

package/src/components/Tables/common/tableStyles.scss

@@ -56,28 +56,28 @@
 
 	// Override Vuetify's checkbox styles to use primary color
 	.v-table .v-selection-control {
-		color: rgb(var(--v-theme-borderAccentPrimary)) !important;
+		color: rgb(var(--v-theme-primary)) !important;
 	}
 
 	.v-table .v-selection-control--dirty .v-selection-control__input::before {
-		background-color: rgb(var(--v-theme-borderAccentPrimary)) !important;
-		border-color: rgb(var(--v-theme-borderAccentPrimary)) !important;
+		background-color: rgb(var(--v-theme-primary)) !important;
+		border-color: rgb(var(--v-theme-primary)) !important;
 	}
 
 	// Target the header checkbox specifically
 	.v-data-table-header__checkbox .v-selection-control {
-		color: rgb(var(--v-theme-borderAccentPrimary)) !important;
+		color: rgb(var(--v-theme-primary)) !important;
 	}
 
 	// Target the row checkboxes specifically
 	.v-data-table-row__checkbox .v-selection-control {
-		color: rgb(var(--v-theme-borderAccentPrimary)) !important;
+		color: rgb(var(--v-theme-primary)) !important;
 	}
 
 	// Add a global style for all checkboxes in the table
 	.v-checkbox .v-selection-control__input::before,
 	.v-checkbox-btn .v-selection-control__input::before {
-		border-color: rgb(var(--v-theme-borderAccentPrimary)) !important;
+		border-color: rgb(var(--v-theme-primary)) !important;
 	}
 
 	.v-data-table-rows-no-data {

package/src/components/Tables/common/types.ts

@@ -106,6 +106,7 @@ export type SyTableProps = {
 	pinnedColumnKey?: string
 	clickableRow?: boolean
 	pageInput?: boolean
+	hideDefaultFooter?: boolean
 }
 
 export type SyServerTableProps = {
@@ -134,4 +135,5 @@ export type SyServerTableProps = {
 	pinnedColumnKey?: string
 	clickableRow?: boolean
 	pageInput?: boolean
+	hideDefaultFooter?: boolean
 }

package/src/components/UploadWorkflow/tests/UploadWorkflow.spec.ts

@@ -48,10 +48,12 @@ describe('UploadWorkflow', () => {
 	})
 
 	it('handles undefined upload list without crashing', async () => {
+		const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
 		const wrapper = mount(UploadWorkflow, {
 			/* eslint-disable-next-line @typescript-eslint/no-explicit-any */
 			props: {} as any,
 		})
+		warnSpy.mockRestore()
 
 		expect(wrapper.html()).toMatchSnapshot()
 		expect(wrapper.findAll('.file-item')).toHaveLength(0)

package/src/components/index.ts

@@ -95,6 +95,7 @@ export { default as ChipList } from './ChipList/ChipList.vue'
 export * from './ChipList/types'
 export { default as CollapsibleList } from './CollapsibleList/CollapsibleList.vue'
 export { default as SyIcon } from './Customs/SyIcon/SyIcon.vue'
+export { default as SyIconButton } from './Customs/SyIconButton/SyIconButton.vue'
 export { default as DataList } from './DataList/DataList.vue'
 export { default as DataListGroup } from './DataListGroup/DataListGroup.vue'
 export { default as DataListItem } from './DataListItem/DataListItem.vue'

package/src/composables/date/tests/useDateFormatDayjs.spec.ts

@@ -2,7 +2,88 @@ import { describe, it, expect } from 'vitest'
 import { formatDate, parseDate } from '../useDateFormatDayjs'
 
 describe('useDateFormatDayjs', () => {
+	describe('formatDate', () => {
+		it('formats a Date object to string according to the specified format', () => {
+			const date = new Date(2023, 0, 15) // 15 janvier 2023
+			expect(formatDate(date, 'DD/MM/YYYY')).toBe('15/01/2023')
+			expect(formatDate(date, 'YYYY-MM-DD')).toBe('2023-01-15')
+		})
+
+		it('returns empty string when date is null or undefined', () => {
+			expect(formatDate(null as unknown as Date, 'DD/MM/YYYY')).toBe('')
+			expect(formatDate(undefined as unknown as Date, 'DD/MM/YYYY')).toBe('')
+		})
+
+		it('handles different date formats correctly', () => {
+			const date = new Date(2023, 11, 31) // 31 décembre 2023
+			expect(formatDate(date, 'DD/MM/YYYY')).toBe('31/12/2023')
+			expect(formatDate(date, 'YYYY-MM-DD')).toBe('2023-12-31')
+		})
+
+		it('handles custom separators correctly', () => {
+			const date = new Date(2023, 0, 15) // 15 janvier 2023
+			expect(formatDate(date, 'DD.MM.YYYY')).toBe('15.01.2023')
+			expect(formatDate(date, 'DD-MM-YYYY')).toBe('15-01-2023')
+			expect(formatDate(date, 'YYYY/MM/DD')).toBe('2023/01/15')
+		})
+	})
+
 	describe('parseDate', () => {
+		it('parses a date string to a Date object according to the specified format', () => {
+			const dateStr = '15/01/2023'
+			const date = parseDate(dateStr, 'DD/MM/YYYY')
+			expect(date).toBeInstanceOf(Date)
+			expect(date?.getFullYear()).toBe(2023)
+			expect(date?.getMonth()).toBe(0) // Janvier = 0
+			expect(date?.getDate()).toBe(15)
+		})
+
+		it('returns null for invalid date strings', () => {
+			expect(parseDate('invalid', 'DD/MM/YYYY')).toBeNull()
+			expect(parseDate('31/02/2023', 'DD/MM/YYYY')).toBeNull() // 31 février n'existe pas
+		})
+
+		it('handles different date formats correctly', () => {
+			expect(parseDate('2023-01-15', 'YYYY-MM-DD')?.getDate()).toBe(15)
+			expect(parseDate('15.01.2023', 'DD.MM.YYYY')?.getDate()).toBe(15)
+		})
+
+		it('returns null when input is null or empty', () => {
+			expect(parseDate(null, 'DD/MM/YYYY')).toBeNull()
+			expect(parseDate('', 'DD/MM/YYYY')).toBeNull()
+		})
+
+		it('handles leap years correctly', () => {
+			// 2020 était une année bissextile
+			expect(parseDate('29/02/2020', 'DD/MM/YYYY')).not.toBeNull()
+			// 2023 n'est pas une année bissextile
+			expect(parseDate('29/02/2023', 'DD/MM/YYYY')).toBeNull()
+		})
+
+		it('returns the Date object as-is when input is already a Date', () => {
+			const original = new Date(2023, 5, 15, 10, 30)
+			const result = parseDate(original, 'DD/MM/YYYY')
+			expect(result).toBe(original) // même référence
+		})
+
+		it('creates dates at midnight (00:00:00.000)', () => {
+			const date = parseDate('15/01/2023', 'DD/MM/YYYY')!
+			expect(date.getHours()).toBe(0)
+			expect(date.getMinutes()).toBe(0)
+			expect(date.getSeconds()).toBe(0)
+			expect(date.getMilliseconds()).toBe(0)
+		})
+
+		it('roundtrip: parseDate then formatDate preserves the same calendar day', () => {
+			const formats = ['DD/MM/YYYY', 'YYYY-MM-DD', 'DD.MM.YYYY']
+			const inputs = ['01/01/2023', '2023-06-30', '31.12.2020']
+			formats.forEach((fmt, i) => {
+				const parsed = parseDate(inputs[i]!, fmt)
+				expect(parsed).not.toBeNull()
+				expect(formatDate(parsed, fmt)).toBe(inputs[i])
+			})
+		})
+
 		it('keeps the same calendar day when formatting back in a negative timezone (UTC-4)', () => {
 			const previousTz = process.env.TZ
 			process.env.TZ = 'America/Guadeloupe'
@@ -15,5 +96,36 @@ describe('useDateFormatDayjs', () => {
 				process.env.TZ = previousTz
 			}
 		})
+
+		it('handles non-string non-Date input by converting to string', () => {
+			// Test avec un nombre qui sera converti en string
+			const result = parseDate(20230115 as unknown as string, 'YYYYMMDD')
+			expect(result).not.toBeNull()
+			expect(result?.getFullYear()).toBe(2023)
+		})
+
+		it('handles undefined input', () => {
+			expect(parseDate(undefined, 'DD/MM/YYYY')).toBeNull()
+		})
+	})
+
+	describe('useDateFormat composable', () => {
+		it('returns parseDate and formatDate functions', async () => {
+			const { useDateFormat } = await import('../useDateFormatDayjs')
+			const hook = useDateFormat()
+			expect(hook.parseDate).toBeDefined()
+			expect(hook.formatDate).toBeDefined()
+			expect(typeof hook.parseDate).toBe('function')
+			expect(typeof hook.formatDate).toBe('function')
+		})
+
+		it('uses returned functions correctly', async () => {
+			const { useDateFormat } = await import('../useDateFormatDayjs')
+			const { parseDate: hookParse, formatDate: hookFormat } = useDateFormat()
+
+			const date = hookParse('15/01/2023', 'DD/MM/YYYY')
+			expect(date).not.toBeNull()
+			expect(hookFormat(date, 'DD/MM/YYYY')).toBe('15/01/2023')
+		})
 	})
 })

package/src/composables/date/tests/{useDateInitialization.spec.ts → useDateInitializationDayjs.spec.ts}

@@ -1,7 +1,7 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
-import { initializeSelectedDates, type DateInput } from '../useDateInitialization'
+import { initializeSelectedDates, type DateInput } from '../useDateInitializationDayjs'
 
-describe('useDateInitialization', () => {
+describe('useDateInitializationDayjs', () => {
 	describe('initializeSelectedDates', () => {
 		it('returns null when modelValue is null or undefined', () => {
 			expect(initializeSelectedDates(null, 'DD/MM/YYYY')).toBeNull()
@@ -70,7 +70,7 @@ describe('useDateInitialization', () => {
 			expect(result1).toBeInstanceOf(Date)
 			expect((result1 as Date).getDate()).toBe(15)
 
-			// Date au format d'affichage quand le format de retour est différen
+			// Date au format d'affichage quand le format de retour est différent
 			const result2 = initializeSelectedDates('15/01/2023', 'DD/MM/YYYY', 'YYYY-MM-DD')
 			expect(result2).toBeInstanceOf(Date)
 			expect((result2 as Date).getDate()).toBe(15)
@@ -97,6 +97,42 @@ describe('useDateInitialization', () => {
 			})
 		})
 
+		it('creates dates at midnight (00:00:00.000)', () => {
+			const result = initializeSelectedDates('15/06/2023', 'DD/MM/YYYY') as Date
+			expect(result.getHours()).toBe(0)
+			expect(result.getMinutes()).toBe(0)
+			expect(result.getSeconds()).toBe(0)
+			expect(result.getMilliseconds()).toBe(0)
+		})
+
+		it('creates dates at midnight for arrays too', () => {
+			const result = initializeSelectedDates(['01/03/2023', '15/03/2023'], 'DD/MM/YYYY') as Date[]
+			result.forEach((date) => {
+				expect(date.getHours()).toBe(0)
+				expect(date.getMinutes()).toBe(0)
+				expect(date.getSeconds()).toBe(0)
+			})
+		})
+
+		it('handles range array with different return format', () => {
+			const result = initializeSelectedDates(['2023-01-10', '2023-01-20'], 'DD/MM/YYYY', 'YYYY-MM-DD')
+			expect(Array.isArray(result)).toBe(true)
+			const dates = result as Date[]
+			expect(dates).toHaveLength(2)
+			expect(dates[0]?.getDate()).toBe(10)
+			expect(dates[1]?.getDate()).toBe(20)
+		})
+
+		it('accepts a range where both dates are equal', () => {
+			const result = initializeSelectedDates(['15/01/2023', '15/01/2023'], 'DD/MM/YYYY')
+			expect(Array.isArray(result)).toBe(true)
+			expect(result).toHaveLength(2)
+		})
+
+		it('returns null for empty string input', () => {
+			expect(initializeSelectedDates('', 'DD/MM/YYYY')).toBeNull()
+		})
+
 		it('returns null for object input', () => {
 			const result = initializeSelectedDates({}, 'DD/MM/YYYY')
 			expect(result).toBeNull()

package/src/composables/date/tests/useHolidayDay.spec.ts

@@ -0,0 +1,109 @@
+import { describe, it, expect } from 'vitest'
+import {
+	getJoursFeries,
+	isHolidayDay,
+	useHolidayDay,
+} from '../useHolidayDay'
+
+describe('useHolidayDay', () => {
+	const { calculPaquesGregorienne } = useHolidayDay()
+
+	describe('calculPaquesGregorienne', () => {
+		it('calculates Easter date for various years', () => {
+			// Pâques 2023: 9 avril
+			const paques2023 = calculPaquesGregorienne(2023)
+			expect(paques2023.jour).toBe(9)
+			expect(paques2023.mois).toBe(4)
+
+			// Pâques 2024: 31 mars
+			const paques2024 = calculPaquesGregorienne(2024)
+			expect(paques2024.jour).toBe(31)
+			expect(paques2024.mois).toBe(3)
+
+			// Pâques 2025: 20 avril
+			const paques2025 = calculPaquesGregorienne(2025)
+			expect(paques2025.jour).toBe(20)
+			expect(paques2025.mois).toBe(4)
+		})
+
+		it('handles years where sum <= 9 (Easter in March)', () => {
+			// Certaines années Pâques tombe en mars (sum <= 9)
+			const paques2016 = calculPaquesGregorienne(2016)
+			expect(paques2016.mois).toBe(3) // 27 mars 2016
+		})
+	})
+
+	describe('getJoursFeries', () => {
+		it('returns a Set of holidays for a given year', () => {
+			const holidays2023 = getJoursFeries(2023)
+			expect(holidays2023).toBeInstanceOf(Set)
+			expect(holidays2023.size).toBe(11) // 11 jours fériés fixes + variables
+		})
+
+		it('includes fixed holidays', () => {
+			const holidays2023 = getJoursFeries(2023)
+			expect(holidays2023.has('01/01/2023')).toBe(true) // Jour de l'an
+			expect(holidays2023.has('01/05/2023')).toBe(true) // Fête du travail
+			expect(holidays2023.has('08/05/2023')).toBe(true) // Victoire
+			expect(holidays2023.has('14/07/2023')).toBe(true) // Fête nationale
+			expect(holidays2023.has('15/08/2023')).toBe(true) // Assomption
+			expect(holidays2023.has('01/11/2023')).toBe(true) // Toussaint
+			expect(holidays2023.has('11/11/2023')).toBe(true) // Armistice
+			expect(holidays2023.has('25/12/2023')).toBe(true) // Noël
+		})
+
+		it('includes Easter-related holidays', () => {
+			const holidays2023 = getJoursFeries(2023)
+			// Pâques 2023: 9 avril
+			expect(holidays2023.has('10/04/2023')).toBe(true) // Lundi de Pâques
+			expect(holidays2023.has('18/05/2023')).toBe(true) // Ascension
+			expect(holidays2023.has('29/05/2023')).toBe(true) // Lundi de Pentecôte
+		})
+
+		it('accepts custom format', () => {
+			const holidays2023 = getJoursFeries(2023, 'YYYY-MM-DD')
+			expect(holidays2023.has('2023-01-01')).toBe(true)
+			expect(holidays2023.has('2023-12-25')).toBe(true)
+		})
+	})
+
+	describe('isHolidayDay', () => {
+		it('returns true for holidays', () => {
+			expect(isHolidayDay(new Date(2023, 0, 1))).toBe(true) // Jour de l'an
+			expect(isHolidayDay(new Date(2023, 4, 1))).toBe(true) // Fête du travail
+			expect(isHolidayDay(new Date(2023, 11, 25))).toBe(true) // Noël
+		})
+
+		it('returns false for non-holidays', () => {
+			expect(isHolidayDay(new Date(2023, 0, 2))).toBe(false) // 2 janvier
+			expect(isHolidayDay(new Date(2023, 5, 15))).toBe(false) // 15 juin
+		})
+
+		it('accepts string dates', () => {
+			expect(isHolidayDay('01/01/2023', 'DD/MM/YYYY')).toBe(true)
+			expect(isHolidayDay('02/01/2023', 'DD/MM/YYYY')).toBe(false)
+		})
+
+		it('accepts custom format', () => {
+			expect(isHolidayDay('2023-01-01', 'YYYY-MM-DD')).toBe(true)
+			expect(isHolidayDay('2023-12-25', 'YYYY-MM-DD')).toBe(true)
+		})
+
+		it('returns false for invalid dates', () => {
+			expect(isHolidayDay('invalid-date', 'DD/MM/YYYY')).toBe(false)
+			expect(isHolidayDay('', 'DD/MM/YYYY')).toBe(false)
+		})
+	})
+
+	describe('useHolidayDay composable', () => {
+		it('returns all functions', () => {
+			const hook = useHolidayDay()
+			expect(hook.getJoursFeries).toBeDefined()
+			expect(hook.isHolidayDay).toBeDefined()
+			expect(hook.calculPaquesGregorienne).toBeDefined()
+			expect(typeof hook.getJoursFeries).toBe('function')
+			expect(typeof hook.isHolidayDay).toBe('function')
+			expect(typeof hook.calculPaquesGregorienne).toBe('function')
+		})
+	})
+})