@cnamts/synapse 1.0.0 → 1.0.2

package/src/components/DatePicker/composables/tests/useDateRangeValidation.spec.ts

@@ -0,0 +1,107 @@
+import { describe, it, expect } from 'vitest'
+import { ref } from 'vue'
+import { useDateRangeValidation } from '../useDateRangeValidation'
+
+describe('useDateRangeValidation', () => {
+	describe('isRangeValid', () => {
+		it('devrait retourner true si la date de début est antérieure à la date de fin', () => {
+			const selectedDates = ref(null)
+			const { isRangeValid } = useDateRangeValidation(selectedDates, true)
+
+			const startDate = new Date('2023-01-01')
+			const endDate = new Date('2023-01-10')
+
+			expect(isRangeValid(startDate, endDate)).toBe(true)
+		})
+
+		it('devrait retourner true si les dates sont identiques', () => {
+			const selectedDates = ref(null)
+			const { isRangeValid } = useDateRangeValidation(selectedDates, true)
+
+			const sameDate = new Date('2023-01-01')
+
+			expect(isRangeValid(sameDate, sameDate)).toBe(true)
+		})
+
+		it('devrait retourner false si la date de début est postérieure à la date de fin', () => {
+			const selectedDates = ref(null)
+			const { isRangeValid } = useDateRangeValidation(selectedDates, true)
+
+			const startDate = new Date('2023-01-10')
+			const endDate = new Date('2023-01-01')
+
+			expect(isRangeValid(startDate, endDate)).toBe(false)
+		})
+
+		it('devrait retourner true si une des dates est null', () => {
+			const selectedDates = ref(null)
+			const { isRangeValid } = useDateRangeValidation(selectedDates, true)
+
+			const date = new Date('2023-01-01')
+
+			expect(isRangeValid(date, null)).toBe(true)
+			expect(isRangeValid(null, date)).toBe(true)
+			expect(isRangeValid(null, null)).toBe(true)
+		})
+	})
+
+	describe('currentRangeIsValid', () => {
+		it('devrait retourner true si displayRange est false', () => {
+			const selectedDates = ref([new Date('2023-01-10'), new Date('2023-01-01')])
+			const { currentRangeIsValid } = useDateRangeValidation(selectedDates, false)
+
+			expect(currentRangeIsValid.value).toBe(true)
+		})
+
+		it('devrait retourner true si selectedDates est null', () => {
+			const selectedDates = ref(null)
+			const { currentRangeIsValid } = useDateRangeValidation(selectedDates, true)
+
+			expect(currentRangeIsValid.value).toBe(true)
+		})
+
+		it('devrait retourner true si selectedDates n\'est pas un tableau', () => {
+			const selectedDates = ref(new Date('2023-01-01'))
+			const { currentRangeIsValid } = useDateRangeValidation(selectedDates, true)
+
+			expect(currentRangeIsValid.value).toBe(true)
+		})
+
+		it('devrait retourner true si selectedDates contient moins de 2 dates', () => {
+			const selectedDates = ref([new Date('2023-01-01')])
+			const { currentRangeIsValid } = useDateRangeValidation(selectedDates, true)
+
+			expect(currentRangeIsValid.value).toBe(true)
+		})
+
+		it('devrait retourner true si la plage est valide', () => {
+			const selectedDates = ref([new Date('2023-01-01'), new Date('2023-01-10')])
+			const { currentRangeIsValid } = useDateRangeValidation(selectedDates, true)
+
+			expect(currentRangeIsValid.value).toBe(true)
+		})
+
+		it('devrait retourner false si la plage est invalide', () => {
+			const selectedDates = ref([new Date('2023-01-10'), new Date('2023-01-01')])
+			const { currentRangeIsValid } = useDateRangeValidation(selectedDates, true)
+
+			expect(currentRangeIsValid.value).toBe(false)
+		})
+	})
+
+	describe('getRangeValidationError', () => {
+		it('devrait retourner une chaîne vide si la plage est valide', () => {
+			const selectedDates = ref([new Date('2023-01-01'), new Date('2023-01-10')])
+			const { getRangeValidationError } = useDateRangeValidation(selectedDates, true)
+
+			expect(getRangeValidationError.value).toBe('')
+		})
+
+		it('devrait retourner un message d\'erreur si la plage est invalide', () => {
+			const selectedDates = ref([new Date('2023-01-10'), new Date('2023-01-01')])
+			const { getRangeValidationError } = useDateRangeValidation(selectedDates, true)
+
+			expect(getRangeValidationError.value).toBe('La date de fin doit être postérieure ou égale à la date de début')
+		})
+	})
+})

package/src/components/DatePicker/composables/tests/useDateSelection.spec.ts

@@ -0,0 +1,171 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { ref } from 'vue'
+import { useDateSelection } from '../useDateSelection'
+
+describe('useDateSelection', () => {
+	// Mocks et setup
+	const mockParseDate = vi.fn()
+	const selectedDates = ref<Date | Date[] | null>(null)
+	const format = 'DD/MM/YYYY'
+
+	beforeEach(() => {
+		// Réinitialiser les mocks et les refs avant chaque test
+		mockParseDate.mockReset()
+		selectedDates.value = null
+	})
+
+	describe('generateDateRange', () => {
+		it('devrait générer un tableau contenant toutes les dates entre deux dates (incluses)', () => {
+			const { generateDateRange } = useDateSelection(mockParseDate, selectedDates, format, true)
+
+			const startDate = new Date('2023-01-01')
+			const endDate = new Date('2023-01-05')
+
+			const result = generateDateRange(startDate, endDate)
+
+			expect(result).toHaveLength(5)
+			expect(result[0].toISOString().split('T')[0]).toBe('2023-01-01')
+			expect(result[1].toISOString().split('T')[0]).toBe('2023-01-02')
+			expect(result[2].toISOString().split('T')[0]).toBe('2023-01-03')
+			expect(result[3].toISOString().split('T')[0]).toBe('2023-01-04')
+			expect(result[4].toISOString().split('T')[0]).toBe('2023-01-05')
+		})
+
+		it('devrait retourner une seule date si les dates de début et de fin sont identiques', () => {
+			const { generateDateRange } = useDateSelection(mockParseDate, selectedDates, format, true)
+
+			const sameDate = new Date('2023-01-01')
+
+			const result = generateDateRange(sameDate, sameDate)
+
+			expect(result).toHaveLength(1)
+			expect(result[0].toISOString().split('T')[0]).toBe('2023-01-01')
+		})
+	})
+
+	describe('updateSelectedDates', () => {
+		it('devrait définir selectedDates à null si l\'entrée est null', () => {
+			const { updateSelectedDates } = useDateSelection(mockParseDate, selectedDates, format, true)
+
+			updateSelectedDates(null)
+
+			expect(selectedDates.value).toBeNull()
+		})
+
+		it('devrait définir selectedDates à null si l\'entrée est undefined', () => {
+			const { updateSelectedDates } = useDateSelection(mockParseDate, selectedDates, format, true)
+
+			updateSelectedDates(undefined)
+
+			expect(selectedDates.value).toBeNull()
+		})
+
+		it('devrait traiter un tableau de dates en mode non-plage', () => {
+			const date1 = new Date('2023-01-01')
+			const date2 = new Date('2023-01-05')
+
+			mockParseDate.mockImplementation((dateStr) => {
+				if (dateStr === date1) return date1
+				if (dateStr === date2) return date2
+				return null
+			})
+
+			const { updateSelectedDates } = useDateSelection(mockParseDate, selectedDates, format, false)
+
+			updateSelectedDates([date1, date2])
+
+			expect(selectedDates.value).toEqual([date1, date2])
+		})
+
+		it('devrait générer une plage de dates en mode plage', () => {
+			const date1 = new Date('2023-01-01')
+			const date2 = new Date('2023-01-03')
+
+			mockParseDate.mockImplementation((dateStr) => {
+				if (dateStr === date1) return date1
+				if (dateStr === date2) return date2
+				return null
+			})
+
+			const { updateSelectedDates, rangeBoundaryDates } = useDateSelection(mockParseDate, selectedDates, format, true)
+
+			updateSelectedDates([date1, date2])
+
+			// Vérifier que selectedDates contient toutes les dates de la plage
+			expect(Array.isArray(selectedDates.value)).toBe(true)
+			expect((selectedDates.value as Date[]).length).toBe(3)
+
+			// Vérifier que rangeBoundaryDates contient les dates de début et de fin
+			expect(rangeBoundaryDates.value).toEqual([date1, date2])
+		})
+
+		it('devrait trier les dates avant de générer une plage', () => {
+			const date1 = new Date('2023-01-01')
+			const date2 = new Date('2023-01-03')
+
+			mockParseDate.mockImplementation((dateStr) => {
+				if (dateStr === date1) return date1
+				if (dateStr === date2) return date2
+				return null
+			})
+
+			const { updateSelectedDates, rangeBoundaryDates } = useDateSelection(mockParseDate, selectedDates, format, true)
+
+			// Dates dans le désordre
+			updateSelectedDates([date2, date1])
+
+			// Vérifier que les dates ont été triées et que la plage est correcte
+			expect(rangeBoundaryDates.value).toEqual([date1, date2])
+		})
+
+		it('devrait traiter une chaîne de caractères en mode non-plage', () => {
+			const date = new Date('2023-01-01')
+
+			mockParseDate.mockReturnValue(date)
+
+			const { updateSelectedDates } = useDateSelection(mockParseDate, selectedDates, format, false)
+
+			updateSelectedDates('01/01/2023')
+
+			expect(selectedDates.value).toEqual(date)
+			expect(mockParseDate).toHaveBeenCalledWith('01/01/2023', format)
+		})
+
+		it('devrait traiter une chaîne de plage de dates en mode plage', () => {
+			const startDate = new Date('2023-01-01')
+			const endDate = new Date('2023-01-05')
+
+			mockParseDate.mockImplementation((dateStr) => {
+				if (dateStr === '01/01/2023') return startDate
+				if (dateStr === '05/01/2023') return endDate
+				return null
+			})
+
+			const { updateSelectedDates, rangeBoundaryDates } = useDateSelection(mockParseDate, selectedDates, format, true)
+
+			updateSelectedDates('01/01/2023 - 05/01/2023')
+
+			// Vérifier que selectedDates contient toutes les dates de la plage
+			expect(Array.isArray(selectedDates.value)).toBe(true)
+			expect((selectedDates.value as Date[]).length).toBe(5)
+
+			// Vérifier que rangeBoundaryDates contient les dates de début et de fin
+			expect(rangeBoundaryDates.value).toEqual([startDate, endDate])
+		})
+
+		it('ne devrait pas modifier selectedDates si une des dates de la plage est invalide', () => {
+			mockParseDate.mockImplementation((dateStr) => {
+				if (dateStr === '01/01/2023') return new Date('2023-01-01')
+				return null
+			})
+
+			const { updateSelectedDates } = useDateSelection(mockParseDate, selectedDates, format, true)
+
+			// Date de fin invalide
+			updateSelectedDates('01/01/2023 - invalidDate')
+
+			// selectedDates ne devrait pas être modifié
+			expect(selectedDates.value).toBeNull()
+		})
+	})
+})

package/src/components/DatePicker/composables/tests/useDateValidation.spec.ts

@@ -0,0 +1,245 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { ref } from 'vue'
+import { useDateValidation } from '../useDateValidation'
+
+describe('useDateValidation', () => {
+	// Mocks et setup
+	const mockClearValidation = vi.fn()
+	const mockValidateField = vi.fn()
+	const errors = ref<string[]>([])
+	const warnings = ref<string[]>([])
+	const successes = ref<string[]>([])
+	const selectedDates = ref<Date | Date[] | null>(null)
+	const isUpdatingFromInternal = ref(false)
+	const currentRangeIsValid = ref(true)
+	const getRangeValidationError = ref('')
+
+	beforeEach(() => {
+		// Réinitialiser les mocks et les refs avant chaque test
+		mockClearValidation.mockReset()
+		mockValidateField.mockReset()
+		errors.value = []
+		warnings.value = []
+		successes.value = []
+		selectedDates.value = null
+		isUpdatingFromInternal.value = false
+		currentRangeIsValid.value = true
+		getRangeValidationError.value = ''
+	})
+
+	it('devrait retourner valid=true en mode noCalendar', () => {
+		const { validateDates } = useDateValidation({
+			noCalendar: true,
+			required: true,
+			selectedDates,
+			isUpdatingFromInternal,
+			currentRangeIsValid,
+			getRangeValidationError,
+			clearValidation: mockClearValidation,
+			validateField: mockValidateField,
+			errors,
+			warnings,
+			successes,
+		})
+
+		const result = validateDates()
+		expect(result.hasError).toBe(false)
+		expect(mockClearValidation).not.toHaveBeenCalled()
+	})
+
+	it('devrait appeler clearValidation lors de la validation', () => {
+		const { validateDates } = useDateValidation({
+			required: false,
+			selectedDates,
+			isUpdatingFromInternal,
+			currentRangeIsValid,
+			getRangeValidationError,
+			clearValidation: mockClearValidation,
+			validateField: mockValidateField,
+			errors,
+			warnings,
+			successes,
+		})
+
+		validateDates()
+		expect(mockClearValidation).toHaveBeenCalledTimes(1)
+	})
+
+	it('devrait retourner une erreur si le champ est requis et vide', () => {
+		const { validateDates } = useDateValidation({
+			required: true,
+			selectedDates,
+			isUpdatingFromInternal,
+			currentRangeIsValid,
+			getRangeValidationError,
+			clearValidation: mockClearValidation,
+			validateField: mockValidateField,
+			errors,
+			warnings,
+			successes,
+		})
+
+		const result = validateDates()
+		expect(result.hasError).toBe(true)
+		expect(result.state.errors[0]).toBe('La date est requise.')
+		expect(errors.value).toContain('La date est requise.')
+	})
+
+	it('ne devrait pas afficher d\'erreur si disableErrorHandling=true', () => {
+		const { validateDates } = useDateValidation({
+			required: true,
+			disableErrorHandling: true,
+			selectedDates,
+			isUpdatingFromInternal,
+			currentRangeIsValid,
+			getRangeValidationError,
+			clearValidation: mockClearValidation,
+			validateField: mockValidateField,
+			errors,
+			warnings,
+			successes,
+		})
+
+		validateDates()
+		expect(errors.value).toHaveLength(0)
+	})
+
+	it('devrait appeler validateField pour chaque date dans un tableau', () => {
+		const today = new Date()
+		const tomorrow = new Date(today)
+		tomorrow.setDate(today.getDate() + 1)
+
+		selectedDates.value = [today, tomorrow]
+
+		mockValidateField.mockReturnValue({ valid: true })
+
+		const { validateDates } = useDateValidation({
+			selectedDates,
+			isUpdatingFromInternal,
+			currentRangeIsValid,
+			getRangeValidationError,
+			clearValidation: mockClearValidation,
+			validateField: mockValidateField,
+			errors,
+			warnings,
+			successes,
+		})
+
+		validateDates()
+		expect(mockValidateField).toHaveBeenCalledTimes(2)
+		expect(mockValidateField).toHaveBeenCalledWith(today, [], [])
+		expect(mockValidateField).toHaveBeenCalledWith(tomorrow, [], [])
+	})
+
+	it('devrait appeler validateField avec les règles personnalisées', () => {
+		selectedDates.value = new Date()
+
+		const customRules = [{ type: 'custom', options: {} }]
+		const customWarningRules = [{ type: 'warning', options: {} }]
+
+		mockValidateField.mockReturnValue({ valid: true })
+
+		const { validateDates } = useDateValidation({
+			customRules,
+			customWarningRules,
+			selectedDates,
+			isUpdatingFromInternal,
+			currentRangeIsValid,
+			getRangeValidationError,
+			clearValidation: mockClearValidation,
+			validateField: mockValidateField,
+			errors,
+			warnings,
+			successes,
+		})
+
+		validateDates()
+		expect(mockValidateField).toHaveBeenCalledWith(
+			selectedDates.value,
+			customRules,
+			customWarningRules,
+		)
+	})
+
+	it('devrait ajouter l\'erreur de plage si displayRange=true et la plage est invalide', () => {
+		selectedDates.value = [new Date(), new Date()]
+		currentRangeIsValid.value = false
+		getRangeValidationError.value = 'La date de fin doit être postérieure ou égale à la date de début'
+
+		mockValidateField.mockReturnValue({ valid: true })
+
+		const { validateDates } = useDateValidation({
+			displayRange: true,
+			selectedDates,
+			isUpdatingFromInternal,
+			currentRangeIsValid,
+			getRangeValidationError,
+			clearValidation: mockClearValidation,
+			validateField: mockValidateField,
+			errors,
+			warnings,
+			successes,
+		})
+
+		const result = validateDates()
+		expect(result.hasError).toBe(true)
+		expect(errors.value).toContain('La date de fin doit être postérieure ou égale à la date de début')
+	})
+
+	it('devrait dédoublonner les messages d\'erreur', () => {
+		selectedDates.value = [new Date(), new Date()]
+
+		// Simuler des erreurs dupliquées
+		mockValidateField.mockImplementation(() => {
+			errors.value.push('Erreur dupliquée')
+			return {
+				hasError: true,
+				hasWarning: false,
+				hasSuccess: false,
+				state: {
+					errors: ['Erreur dupliquée'],
+					warnings: [],
+					successes: [],
+				},
+			}
+		})
+
+		const { validateDates } = useDateValidation({
+			selectedDates,
+			isUpdatingFromInternal,
+			currentRangeIsValid,
+			getRangeValidationError,
+			clearValidation: mockClearValidation,
+			validateField: mockValidateField,
+			errors,
+			warnings,
+			successes,
+		})
+
+		validateDates()
+		// Même avec 2 appels qui ajoutent la même erreur, on ne devrait avoir qu'une seule occurrence
+		expect(errors.value).toEqual(['Erreur dupliquée'])
+	})
+
+	it('devrait forcer la validation avec validateOnSubmit', () => {
+		isUpdatingFromInternal.value = true
+		selectedDates.value = null
+
+		const { validateOnSubmit } = useDateValidation({
+			required: true,
+			selectedDates,
+			isUpdatingFromInternal,
+			currentRangeIsValid,
+			getRangeValidationError,
+			clearValidation: mockClearValidation,
+			validateField: mockValidateField,
+			errors,
+			warnings,
+			successes,
+		})
+
+		const result = validateOnSubmit()
+		expect(result.hasError).toBe(true)
+		expect(errors.value).toContain('La date est requise.')
+	})
+})

package/src/components/DatePicker/composables/tests/useDisplayedDateString.spec.ts

@@ -0,0 +1,98 @@
+import { describe, it, expect, vi } from 'vitest'
+import { useDisplayedDateString } from '../useDisplayedDateString'
+import { computed } from 'vue'
+
+// Mock pour dayjs
+vi.mock('dayjs', () => {
+	const mockDayjs = (date: Date | string | null) => {
+		// Si la date est null, retourner un objet avec isValid = false
+		if (date === null) {
+			return {
+				isValid: () => false,
+				format: vi.fn(),
+			}
+		}
+
+		// Simuler différents formats de date en fonction de l'entrée
+		return {
+			isValid: () => true,
+			format: (format: string) => {
+				if (format === 'D MMMM') {
+					return '1 janvier'
+				}
+				if (format === 'D MMMM YYYY') {
+					return '1 janvier 2025'
+				}
+				if (format === 'dddd D MMMM YYYY') {
+					return 'jeudi 1 janvier 2025'
+				}
+				return 'date formatée'
+			},
+		}
+	}
+
+	return {
+		default: mockDayjs,
+	}
+})
+
+describe('useDisplayedDateString', () => {
+	const todayInString = computed(() => 'Jeudi 1 Janvier 2025')
+
+	it('devrait initialiser correctement', () => {
+		const { displayedDateString } = useDisplayedDateString({
+			selectedDates: { value: null },
+			todayInString,
+		})
+		expect(displayedDateString).toBeDefined()
+	})
+
+	it('devrait retourner la date du jour si aucune date n\'est sélectionnée', () => {
+		const { displayedDateString } = useDisplayedDateString({
+			selectedDates: { value: null },
+			todayInString,
+		})
+		expect(displayedDateString.value).toBe('Jeudi 1 Janvier 2025')
+	})
+
+	it('devrait formater correctement une date unique', () => {
+		const { displayedDateString } = useDisplayedDateString({
+			selectedDates: { value: new Date('2025-01-01') },
+			todayInString,
+		})
+		expect(displayedDateString.value).toBe('jeudi 1 janvier 2025')
+	})
+
+	it('devrait formater correctement une plage de dates avec deux dates', () => {
+		const { displayedDateString } = useDisplayedDateString({
+			selectedDates: { value: [new Date('2025-01-01'), new Date('2025-01-15')] },
+			todayInString,
+		})
+		expect(displayedDateString.value).toBe('1 janvier - 1 janvier 2025')
+	})
+
+	it('devrait formater correctement une plage de dates avec une seule date', () => {
+		const { displayedDateString } = useDisplayedDateString({
+			selectedDates: { value: [new Date('2025-01-01')] },
+			todayInString,
+		})
+		expect(displayedDateString.value).toBe('jeudi 1 janvier 2025')
+	})
+
+	it('devrait retourner la date du jour si la date est invalide', () => {
+		// Utiliser un objet Date invalide pour simuler une date non valide
+		const { displayedDateString } = useDisplayedDateString({
+			selectedDates: { value: new Date('invalid date') },
+			todayInString,
+		})
+		expect(displayedDateString.value).toBe('jeudi 1 janvier 2025')
+	})
+
+	it('devrait retourner la date du jour si la plage de dates est vide', () => {
+		const { displayedDateString } = useDisplayedDateString({
+			selectedDates: { value: [] },
+			todayInString,
+		})
+		expect(displayedDateString.value).toBe('Jeudi 1 Janvier 2025')
+	})
+})