@osimatic/helpers-js 1.4.24 → 1.4.25

package/tests/date_time/SqlDate.test.js

@@ -0,0 +1,205 @@
+const { SqlDate } = require('../../date_time');
+
+describe('SqlDate', () => {
+	describe('parse', () => {
+		test('should parse SQL date to Date object', () => {
+			const sqlDate = '2024-01-15';
+			const result = SqlDate.parse(sqlDate);
+			expect(result instanceof Date).toBe(true);
+			expect(result.getUTCFullYear()).toBe(2024);
+			expect(result.getUTCMonth()).toBe(0);
+			expect(result.getUTCDate()).toBe(15);
+		});
+
+		test('should return null for null input', () => {
+			expect(SqlDate.parse(null)).toBeNull();
+		});
+
+		test('should parse last day of month', () => {
+			const sqlDate = '2024-01-31';
+			const result = SqlDate.parse(sqlDate);
+			expect(result.getUTCDate()).toBe(31);
+		});
+
+		test('should parse February 29 in leap year', () => {
+			const sqlDate = '2024-02-29';
+			const result = SqlDate.parse(sqlDate);
+			expect(result.getUTCMonth()).toBe(1);
+			expect(result.getUTCDate()).toBe(29);
+		});
+	});
+
+	describe('getCurrentSqlDate', () => {
+		test('should return current date in SQL format', () => {
+			const result = SqlDate.getCurrentSqlDate();
+			expect(result).toMatch(/^\d{4}-\d{2}-\d{2}$/);
+		});
+
+		test('should return today\'s date', () => {
+			const result = SqlDate.getCurrentSqlDate();
+			const today = new Date();
+			const year = today.getFullYear();
+			expect(result).toContain(String(year));
+		});
+	});
+
+	describe('getDateDigitalDisplay', () => {
+		test('should format SQL date in digital format', () => {
+			const sqlDate = '2024-01-15';
+			const result = SqlDate.getDateDigitalDisplay(sqlDate, 'fr-FR', 'UTC');
+			expect(result).toContain('15');
+			expect(result).toContain('01');
+			expect(result).toContain('2024');
+		});
+
+		test('should work with different locales', () => {
+			const sqlDate = '2024-01-15';
+			const resultFr = SqlDate.getDateDigitalDisplay(sqlDate, 'fr-FR', 'UTC');
+			const resultEn = SqlDate.getDateDigitalDisplay(sqlDate, 'en-US', 'UTC');
+			expect(resultFr).toBeTruthy();
+			expect(resultEn).toBeTruthy();
+		});
+	});
+
+	describe('getDateTextDisplay', () => {
+		test('should format SQL date in text format', () => {
+			const sqlDate = '2024-01-15';
+			const result = SqlDate.getDateTextDisplay(sqlDate, 'fr-FR', 'UTC');
+			expect(typeof result).toBe('string');
+			expect(result.length).toBeGreaterThan(10);
+		});
+
+		test('should include month name', () => {
+			const sqlDate = '2024-01-15';
+			const result = SqlDate.getDateTextDisplay(sqlDate, 'fr-FR', 'UTC');
+			expect(result).toContain('janvier');
+		});
+	});
+
+	describe('getDateForInputDate', () => {
+		test('should return date in input format', () => {
+			const sqlDate = '2024-01-15';
+			const result = SqlDate.getDateForInputDate(sqlDate, 'UTC');
+			expect(result).toBe('2024-01-15');
+		});
+	});
+
+	describe('getTimestamp', () => {
+		test('should convert SQL date to timestamp', () => {
+			const sqlDate = '2024-01-15';
+			const result = SqlDate.getTimestamp(sqlDate);
+			expect(typeof result).toBe('number');
+			expect(result).toBeGreaterThan(0);
+		});
+
+		test('should return consistent timestamp', () => {
+			const sqlDate = '2024-01-15';
+			const result1 = SqlDate.getTimestamp(sqlDate);
+			const result2 = SqlDate.getTimestamp(sqlDate);
+			expect(result1).toBe(result2);
+		});
+	});
+
+	describe('getYear', () => {
+		test('should return year from SQL date', () => {
+			const sqlDate = '2024-01-15';
+			expect(SqlDate.getYear(sqlDate)).toBe(2024);
+		});
+
+		test('should work with different years', () => {
+			expect(SqlDate.getYear('2020-01-15')).toBe(2020);
+			expect(SqlDate.getYear('2030-12-31')).toBe(2030);
+		});
+	});
+
+	describe('getMonth', () => {
+		test('should return month from SQL date', () => {
+			const sqlDate = '2024-01-15';
+			expect(SqlDate.getMonth(sqlDate)).toBe(1);
+		});
+
+		test('should return 12 for December', () => {
+			const sqlDate = '2024-12-15';
+			expect(SqlDate.getMonth(sqlDate)).toBe(12);
+		});
+	});
+
+	describe('getMonthName', () => {
+		test('should return month name from SQL date', () => {
+			const sqlDate = '2024-01-15';
+			expect(SqlDate.getMonthName(sqlDate, 'fr-FR')).toBe('janvier');
+		});
+
+		test('should return short month name', () => {
+			const sqlDate = '2024-01-15';
+			const result = SqlDate.getMonthName(sqlDate, 'fr-FR', true);
+			expect(result).toContain('janv');
+		});
+
+		test('should work with different months', () => {
+			expect(SqlDate.getMonthName('2024-06-15', 'fr-FR')).toBe('juin');
+			expect(SqlDate.getMonthName('2024-12-15', 'fr-FR')).toBe('décembre');
+		});
+	});
+
+	describe('getDay', () => {
+		test('should return day from SQL date', () => {
+			const sqlDate = '2024-01-15';
+			expect(SqlDate.getDay(sqlDate)).toBe(15);
+		});
+
+		test('should work with first day of month', () => {
+			const sqlDate = '2024-01-01';
+			expect(SqlDate.getDay(sqlDate)).toBe(1);
+		});
+
+		test('should work with last day of month', () => {
+			const sqlDate = '2024-01-31';
+			expect(SqlDate.getDay(sqlDate)).toBe(31);
+		});
+	});
+
+	describe('isDateInTheFuture', () => {
+		test('should return true for future date', () => {
+			const sqlDate = '2030-01-01';
+			expect(SqlDate.isDateInTheFuture(sqlDate)).toBe(true);
+		});
+
+		test('should return false for past date', () => {
+			const sqlDate = '2020-01-01';
+			expect(SqlDate.isDateInTheFuture(sqlDate)).toBe(false);
+		});
+	});
+
+	describe('getNbDayBetweenTwo', () => {
+		test('should calculate days between two SQL dates', () => {
+			const sqlDate1 = '2024-01-15';
+			const sqlDate2 = '2024-01-20';
+			expect(SqlDate.getNbDayBetweenTwo(sqlDate1, sqlDate2, true)).toBe(5);
+		});
+
+		test('should return 0 for same date', () => {
+			const sqlDate1 = '2024-01-15';
+			const sqlDate2 = '2024-01-15';
+			expect(SqlDate.getNbDayBetweenTwo(sqlDate1, sqlDate2, true)).toBe(0);
+		});
+
+		test('should return negative for reversed dates', () => {
+			const sqlDate1 = '2024-01-20';
+			const sqlDate2 = '2024-01-15';
+			expect(SqlDate.getNbDayBetweenTwo(sqlDate1, sqlDate2, true)).toBe(-5);
+		});
+
+		test('should work across months', () => {
+			const sqlDate1 = '2024-01-30';
+			const sqlDate2 = '2024-02-05';
+			expect(SqlDate.getNbDayBetweenTwo(sqlDate1, sqlDate2, true)).toBe(6);
+		});
+
+		test('should work across years', () => {
+			const sqlDate1 = '2023-12-30';
+			const sqlDate2 = '2024-01-05';
+			expect(SqlDate.getNbDayBetweenTwo(sqlDate1, sqlDate2, true)).toBe(6);
+		});
+	});
+});

package/tests/date_time/SqlDateTime.test.js

@@ -0,0 +1,326 @@
+const { SqlDateTime } = require('../../date_time');
+
+describe('SqlDateTime', () => {
+	describe('parse', () => {
+		test('should parse SQL datetime to Date object', () => {
+			const sqlDateTime = '2024-01-15 10:30:45';
+			const result = SqlDateTime.parse(sqlDateTime);
+			expect(result instanceof Date).toBe(true);
+			expect(result.getUTCFullYear()).toBe(2024);
+			expect(result.getUTCMonth()).toBe(0);
+			expect(result.getUTCDate()).toBe(15);
+			expect(result.getUTCHours()).toBe(10);
+			expect(result.getUTCMinutes()).toBe(30);
+			expect(result.getUTCSeconds()).toBe(45);
+		});
+
+		test('should return null for null input', () => {
+			expect(SqlDateTime.parse(null)).toBeNull();
+		});
+
+		test('should parse midnight', () => {
+			const sqlDateTime = '2024-01-15 00:00:00';
+			const result = SqlDateTime.parse(sqlDateTime);
+			expect(result.getUTCHours()).toBe(0);
+		});
+
+		test('should parse end of day', () => {
+			const sqlDateTime = '2024-01-15 23:59:59';
+			const result = SqlDateTime.parse(sqlDateTime);
+			expect(result.getUTCHours()).toBe(23);
+			expect(result.getUTCMinutes()).toBe(59);
+			expect(result.getUTCSeconds()).toBe(59);
+		});
+	});
+
+	describe('getCurrentSqlDateTime', () => {
+		test('should return current datetime in SQL format', () => {
+			const result = SqlDateTime.getCurrentSqlDateTime();
+			expect(result).toMatch(/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/);
+		});
+
+		test('should return current date and time', () => {
+			const result = SqlDateTime.getCurrentSqlDateTime();
+			const now = new Date();
+			const year = now.getFullYear();
+			expect(result).toContain(String(year));
+		});
+	});
+
+	describe('getSqlDate', () => {
+		test('should extract date from SQL datetime', () => {
+			const sqlDateTime = '2024-01-15 10:30:45';
+			const result = SqlDateTime.getSqlDate(sqlDateTime);
+			expect(result).toBe('2024-01-15');
+		});
+
+		test('should return null for null input', () => {
+			expect(SqlDateTime.getSqlDate(null)).toBeNull();
+		});
+	});
+
+	describe('getSqlTime', () => {
+		test('should extract time from SQL datetime', () => {
+			const sqlDateTime = '2024-01-15 10:30:45';
+			const result = SqlDateTime.getSqlTime(sqlDateTime);
+			expect(result).toBe('10:30:45');
+		});
+
+		test('should return null for null input', () => {
+			expect(SqlDateTime.getSqlTime(null)).toBeNull();
+		});
+
+		test('should handle midnight', () => {
+			const sqlDateTime = '2024-01-15 00:00:00';
+			const result = SqlDateTime.getSqlTime(sqlDateTime);
+			expect(result).toBe('00:00:00');
+		});
+	});
+
+	describe('getDateDigitalDisplay', () => {
+		test('should format date in digital format', () => {
+			const sqlDateTime = '2024-01-15 10:30:45';
+			const result = SqlDateTime.getDateDigitalDisplay(sqlDateTime, 'fr-FR', 'UTC');
+			expect(result).toContain('15');
+			expect(result).toContain('01');
+			expect(result).toContain('2024');
+		});
+
+		test('should work with different locales', () => {
+			const sqlDateTime = '2024-01-15 10:30:45';
+			const resultFr = SqlDateTime.getDateDigitalDisplay(sqlDateTime, 'fr-FR', 'UTC');
+			const resultEn = SqlDateTime.getDateDigitalDisplay(sqlDateTime, 'en-US', 'UTC');
+			expect(resultFr).toBeTruthy();
+			expect(resultEn).toBeTruthy();
+		});
+	});
+
+	describe('getDateTextDisplay', () => {
+		test('should format date in text format', () => {
+			const sqlDateTime = '2024-01-15 10:30:45';
+			const result = SqlDateTime.getDateTextDisplay(sqlDateTime, 'fr-FR', 'UTC');
+			expect(typeof result).toBe('string');
+			expect(result.length).toBeGreaterThan(10);
+		});
+
+		test('should include month name', () => {
+			const sqlDateTime = '2024-01-15 10:30:45';
+			const result = SqlDateTime.getDateTextDisplay(sqlDateTime, 'fr-FR', 'UTC');
+			expect(result).toContain('janvier');
+		});
+	});
+
+	describe('getTimeDisplay', () => {
+		test('should format time for display', () => {
+			const sqlDateTime = '2024-01-15 10:30:45';
+			const result = SqlDateTime.getTimeDisplay(sqlDateTime, 'fr-FR', 'UTC');
+			expect(result).toContain('10');
+			expect(result).toContain('30');
+		});
+
+		test('should format midnight', () => {
+			const sqlDateTime = '2024-01-15 00:00:00';
+			const result = SqlDateTime.getTimeDisplay(sqlDateTime, 'fr-FR', 'UTC');
+			expect(result).toContain('00');
+		});
+	});
+
+	describe('getTimeDisplayWithNbDays', () => {
+		test('should display time without days difference', () => {
+			const sqlDateTime = '2024-01-15 10:30:00';
+			const result = SqlDateTime.getTimeDisplayWithNbDays(sqlDateTime, '2024-01-15 10:30:00', 'fr-FR', 'UTC');
+			expect(result).toContain('10');
+			expect(result).toContain('30');
+		});
+
+		test('should display time with days difference', () => {
+			const sqlDateTime1 = '2024-01-15 10:30:00';
+			const sqlDateTime2 = '2024-01-18 14:30:00';
+			const result = SqlDateTime.getTimeDisplayWithNbDays(sqlDateTime2, sqlDateTime1, 'fr-FR', 'UTC');
+			expect(result).toContain('J+3');
+		});
+
+		test('should not display days when difference is 0', () => {
+			const sqlDateTime1 = '2024-01-15 10:30:00';
+			const sqlDateTime2 = '2024-01-15 14:30:00';
+			const result = SqlDateTime.getTimeDisplayWithNbDays(sqlDateTime2, sqlDateTime1, 'fr-FR', 'UTC');
+			expect(result).not.toContain('J+');
+		});
+	});
+
+	describe('getTimeDigitalDisplay', () => {
+		test('should format time in digital format', () => {
+			const sqlDateTime = '2024-01-15 10:30:45';
+			const result = SqlDateTime.getTimeDigitalDisplay(sqlDateTime, 'fr-FR', 'UTC');
+			expect(result).toMatch(/\d{2}:\d{2}:\d{2}/);
+		});
+	});
+
+	describe('getDateTimeDigitalDisplay', () => {
+		test('should format datetime in digital format', () => {
+			const sqlDateTime = '2024-01-15 10:30:45';
+			const result = SqlDateTime.getDateTimeDigitalDisplay(sqlDateTime, 'fr-FR', 'UTC');
+			expect(result).toContain('15');
+			expect(result).toContain('10');
+			expect(result).toContain('30');
+		});
+
+		test('should include both date and time', () => {
+			const sqlDateTime = '2024-01-15 10:30:45';
+			const result = SqlDateTime.getDateTimeDigitalDisplay(sqlDateTime, 'fr-FR', 'UTC');
+			expect(result).toContain('2024');
+		});
+	});
+
+	describe('getDateForInputDate', () => {
+		test('should return date in input format', () => {
+			const sqlDateTime = '2024-01-15 10:30:45';
+			const result = SqlDateTime.getDateForInputDate(sqlDateTime, 'UTC');
+			expect(result).toBe('2024-01-15');
+		});
+	});
+
+	describe('getTimeForInputTime', () => {
+		test('should return time without seconds', () => {
+			const sqlDateTime = '2024-01-15 10:30:45';
+			const result = SqlDateTime.getTimeForInputTime(sqlDateTime, 'UTC', false);
+			expect(result).toMatch(/^\d{2}:\d{2}$/);
+		});
+
+		test('should return time with seconds', () => {
+			const sqlDateTime = '2024-01-15 10:30:45';
+			const result = SqlDateTime.getTimeForInputTime(sqlDateTime, 'UTC', true);
+			expect(result).toMatch(/^\d{2}:\d{2}:\d{2}$/);
+		});
+	});
+
+	describe('getYear', () => {
+		test('should return year from SQL datetime', () => {
+			const sqlDateTime = '2024-01-15 10:30:45';
+			expect(SqlDateTime.getYear(sqlDateTime)).toBe(2024);
+		});
+
+		test('should work with different years', () => {
+			expect(SqlDateTime.getYear('2020-01-15 10:30:45')).toBe(2020);
+			expect(SqlDateTime.getYear('2030-12-31 23:59:59')).toBe(2030);
+		});
+	});
+
+	describe('getMonth', () => {
+		test('should return month from SQL datetime', () => {
+			const sqlDateTime = '2024-01-15 10:30:45';
+			expect(SqlDateTime.getMonth(sqlDateTime)).toBe(1);
+		});
+
+		test('should return 12 for December', () => {
+			const sqlDateTime = '2024-12-15 10:30:45';
+			expect(SqlDateTime.getMonth(sqlDateTime)).toBe(12);
+		});
+	});
+
+	describe('getMonthName', () => {
+		test('should return month name from SQL datetime', () => {
+			const sqlDateTime = '2024-01-15 10:30:45';
+			expect(SqlDateTime.getMonthName(sqlDateTime, 'fr-FR')).toBe('janvier');
+		});
+
+		test('should work with different months', () => {
+			expect(SqlDateTime.getMonthName('2024-06-15 10:30:45', 'fr-FR')).toBe('juin');
+			expect(SqlDateTime.getMonthName('2024-12-15 10:30:45', 'fr-FR')).toBe('décembre');
+		});
+
+		test('should work with English locale', () => {
+			const sqlDateTime = '2024-01-15 10:30:45';
+			expect(SqlDateTime.getMonthName(sqlDateTime, 'en-US')).toBe('January');
+		});
+	});
+
+	describe('getDay', () => {
+		test('should return day from SQL datetime', () => {
+			const sqlDateTime = '2024-01-15 10:30:45';
+			expect(SqlDateTime.getDay(sqlDateTime)).toBe(15);
+		});
+
+		test('should work with first day of month', () => {
+			const sqlDateTime = '2024-01-01 10:30:45';
+			expect(SqlDateTime.getDay(sqlDateTime)).toBe(1);
+		});
+
+		test('should work with last day of month', () => {
+			const sqlDateTime = '2024-01-31 10:30:45';
+			expect(SqlDateTime.getDay(sqlDateTime)).toBe(31);
+		});
+	});
+
+	describe('getTimestamp', () => {
+		test('should convert SQL datetime to Unix timestamp', () => {
+			const sqlDateTime = '2024-01-15 10:30:00';
+			const result = SqlDateTime.getTimestamp(sqlDateTime);
+			expect(typeof result).toBe('number');
+			expect(result).toBeGreaterThan(0);
+		});
+
+		test('should return consistent timestamp', () => {
+			const sqlDateTime = '2024-01-15 10:30:00';
+			const result1 = SqlDateTime.getTimestamp(sqlDateTime);
+			const result2 = SqlDateTime.getTimestamp(sqlDateTime);
+			expect(result1).toBe(result2);
+		});
+	});
+
+	describe('isDateInTheFuture', () => {
+		test('should return true for future date', () => {
+			const sqlDateTime = '2030-01-01 10:30:00';
+			expect(SqlDateTime.isDateInTheFuture(sqlDateTime)).toBe(true);
+		});
+
+		test('should return false for past date', () => {
+			const sqlDateTime = '2020-01-01 10:30:00';
+			expect(SqlDateTime.isDateInTheFuture(sqlDateTime)).toBe(false);
+		});
+	});
+
+	describe('isDateTimeInTheFuture', () => {
+		test('should return true for future datetime', () => {
+			const sqlDateTime = '2030-01-01 10:30:00';
+			expect(SqlDateTime.isDateTimeInTheFuture(sqlDateTime)).toBe(true);
+		});
+
+		test('should return false for past datetime', () => {
+			const sqlDateTime = '2020-01-01 10:30:00';
+			expect(SqlDateTime.isDateTimeInTheFuture(sqlDateTime)).toBe(false);
+		});
+	});
+
+	describe('getNbDayBetweenTwo', () => {
+		test('should calculate days between two SQL datetimes', () => {
+			const sqlDateTime1 = '2024-01-15 10:30:00';
+			const sqlDateTime2 = '2024-01-20 14:45:00';
+			expect(SqlDateTime.getNbDayBetweenTwo(sqlDateTime1, sqlDateTime2, true)).toBe(5);
+		});
+
+		test('should return 0 for same day', () => {
+			const sqlDateTime1 = '2024-01-15 10:30:00';
+			const sqlDateTime2 = '2024-01-15 14:45:00';
+			expect(SqlDateTime.getNbDayBetweenTwo(sqlDateTime1, sqlDateTime2, false)).toBe(0);
+		});
+
+		test('should return negative for reversed dates', () => {
+			const sqlDateTime1 = '2024-01-20 10:30:00';
+			const sqlDateTime2 = '2024-01-15 14:45:00';
+			expect(SqlDateTime.getNbDayBetweenTwo(sqlDateTime1, sqlDateTime2, true)).toBe(-5);
+		});
+
+		test('should work across months', () => {
+			const sqlDateTime1 = '2024-01-30 10:00:00';
+			const sqlDateTime2 = '2024-02-05 14:00:00';
+			expect(SqlDateTime.getNbDayBetweenTwo(sqlDateTime1, sqlDateTime2, true)).toBe(6);
+		});
+
+		test('should work across years', () => {
+			const sqlDateTime1 = '2023-12-30 10:00:00';
+			const sqlDateTime2 = '2024-01-05 14:00:00';
+			expect(SqlDateTime.getNbDayBetweenTwo(sqlDateTime1, sqlDateTime2, true)).toBe(6);
+		});
+	});
+});

package/tests/date_time/SqlTime.test.js

@@ -0,0 +1,162 @@
+const { SqlTime } = require('../../date_time');
+
+describe('SqlTime', () => {
+	describe('parse', () => {
+		test('should parse SQL time with seconds to Date object', () => {
+			const sqlTime = '10:30:45';
+			const result = SqlTime.parse(sqlTime);
+			expect(result instanceof Date).toBe(true);
+			expect(result.getUTCHours()).toBe(10);
+			expect(result.getUTCMinutes()).toBe(30);
+			expect(result.getUTCSeconds()).toBe(45);
+		});
+
+		test('should parse SQL time without seconds', () => {
+			const sqlTime = '10:30';
+			const result = SqlTime.parse(sqlTime);
+			expect(result instanceof Date).toBe(true);
+			expect(result.getUTCHours()).toBe(10);
+			expect(result.getUTCMinutes()).toBe(30);
+			expect(result.getUTCSeconds()).toBe(0);
+		});
+
+		test('should return null for null input', () => {
+			expect(SqlTime.parse(null)).toBeNull();
+		});
+
+		test('should parse midnight', () => {
+			const sqlTime = '00:00:00';
+			const result = SqlTime.parse(sqlTime);
+			expect(result.getUTCHours()).toBe(0);
+			expect(result.getUTCMinutes()).toBe(0);
+			expect(result.getUTCSeconds()).toBe(0);
+		});
+
+		test('should parse noon', () => {
+			const sqlTime = '12:00:00';
+			const result = SqlTime.parse(sqlTime);
+			expect(result.getUTCHours()).toBe(12);
+		});
+
+		test('should parse end of day', () => {
+			const sqlTime = '23:59:59';
+			const result = SqlTime.parse(sqlTime);
+			expect(result.getUTCHours()).toBe(23);
+			expect(result.getUTCMinutes()).toBe(59);
+			expect(result.getUTCSeconds()).toBe(59);
+		});
+	});
+
+	describe('getCurrentSqlTime', () => {
+		test('should return current time in SQL format', () => {
+			const result = SqlTime.getCurrentSqlTime();
+			expect(result).toMatch(/^\d{2}:\d{2}:\d{2}$/);
+		});
+
+		test('should return time within valid range', () => {
+			const result = SqlTime.getCurrentSqlTime();
+			const parts = result.split(':');
+			const hours = parseInt(parts[0]);
+			const minutes = parseInt(parts[1]);
+			const seconds = parseInt(parts[2]);
+
+			expect(hours).toBeGreaterThanOrEqual(0);
+			expect(hours).toBeLessThanOrEqual(23);
+			expect(minutes).toBeGreaterThanOrEqual(0);
+			expect(minutes).toBeLessThanOrEqual(59);
+			expect(seconds).toBeGreaterThanOrEqual(0);
+			expect(seconds).toBeLessThanOrEqual(59);
+		});
+	});
+
+	describe('getTimeDisplay', () => {
+		test('should format SQL time for display', () => {
+			const sqlTime = '10:30:45';
+			const result = SqlTime.getTimeDisplay(sqlTime, 'fr-FR', 'UTC');
+			expect(result).toContain('10');
+			expect(result).toContain('30');
+		});
+
+		test('should format midnight', () => {
+			const sqlTime = '00:00:00';
+			const result = SqlTime.getTimeDisplay(sqlTime, 'fr-FR', 'UTC');
+			expect(result).toContain('00');
+		});
+	});
+
+	describe('getTimeDigitalDisplay', () => {
+		test('should format SQL time in digital format', () => {
+			const sqlTime = '10:30:45';
+			const result = SqlTime.getTimeDigitalDisplay(sqlTime, 'fr-FR', 'UTC');
+			expect(result).toMatch(/\d{2}:\d{2}:\d{2}/);
+		});
+
+		test('should format time without seconds', () => {
+			const sqlTime = '10:30';
+			const result = SqlTime.getTimeDigitalDisplay(sqlTime, 'fr-FR', 'UTC');
+			expect(result).toMatch(/\d{2}:\d{2}:\d{2}/);
+		});
+	});
+
+	describe('getTimeDisplayWithNbDays', () => {
+		test('should display time without days difference', () => {
+			const sqlTime = '10:30:00';
+			const result = SqlTime.getTimeDisplayWithNbDays(sqlTime, '10:30:00', 'fr-FR', 'UTC');
+			expect(result).toContain('10');
+			expect(result).toContain('30');
+		});
+
+		test('should not show days for same time', () => {
+			const sqlTime = '10:30:00';
+			const result = SqlTime.getTimeDisplayWithNbDays(sqlTime, '10:30:00', 'fr-FR', 'UTC');
+			expect(result).not.toContain('J+');
+		});
+	});
+
+	describe('getTimeForInputTime', () => {
+		test('should return time for input field without seconds', () => {
+			const sqlTime = '10:30:45';
+			const result = SqlTime.getTimeForInputTime(sqlTime, 'UTC', false);
+			expect(result).toMatch(/^\d{2}:\d{2}$/);
+		});
+
+		test('should return time for input field with seconds', () => {
+			const sqlTime = '10:30:45';
+			const result = SqlTime.getTimeForInputTime(sqlTime, 'UTC', true);
+			expect(result).toMatch(/^\d{2}:\d{2}:\d{2}$/);
+		});
+
+		test('should handle time without seconds', () => {
+			const sqlTime = '10:30';
+			const result = SqlTime.getTimeForInputTime(sqlTime, 'UTC', true);
+			expect(result).toMatch(/^\d{2}:\d{2}:\d{2}$/);
+		});
+	});
+
+	describe('getTimestamp', () => {
+		test('should convert SQL time to timestamp', () => {
+			const sqlTime = '10:30:45';
+			const result = SqlTime.getTimestamp(sqlTime);
+			expect(typeof result).toBe('number');
+		});
+
+		test('should return consistent timestamp', () => {
+			const sqlTime = '10:30:45';
+			const result1 = SqlTime.getTimestamp(sqlTime);
+			const result2 = SqlTime.getTimestamp(sqlTime);
+			expect(result1).toBe(result2);
+		});
+
+		test('should handle midnight', () => {
+			const sqlTime = '00:00:00';
+			const result = SqlTime.getTimestamp(sqlTime);
+			expect(typeof result).toBe('number');
+		});
+
+		test('should handle time without seconds', () => {
+			const sqlTime = '10:30';
+			const result = SqlTime.getTimestamp(sqlTime);
+			expect(typeof result).toBe('number');
+		});
+	});
+});