@osimatic/helpers-js 1.4.24 → 1.4.26

package/tests/date_time/TimestampUnix.test.js

@@ -0,0 +1,262 @@
+const { TimestampUnix } = require('../../date_time');
+
+describe('TimestampUnix', () => {
+	describe('parse', () => {
+		test('should parse Unix timestamp to Date', () => {
+			const timestamp = 1705314600; // 2024-01-15 10:30:00 UTC
+			const result = TimestampUnix.parse(timestamp);
+			expect(result instanceof Date).toBe(true);
+			expect(result.getTime()).toBe(1705314600000);
+		});
+
+		test('should return null for null input', () => {
+			expect(TimestampUnix.parse(null)).toBeNull();
+		});
+
+		test('should handle timestamp 0', () => {
+			const result = TimestampUnix.parse(0);
+			expect(result.getTime()).toBe(0);
+		});
+	});
+
+	describe('getCurrent', () => {
+		test('should return current Unix timestamp', () => {
+			const result = TimestampUnix.getCurrent();
+			const now = Math.trunc(Date.now() / 1000);
+			expect(result).toBeCloseTo(now, 0);
+		});
+
+		test('should return an integer', () => {
+			const result = TimestampUnix.getCurrent();
+			expect(Number.isInteger(result)).toBe(true);
+		});
+	});
+
+	describe('getDateDigitalDisplay', () => {
+		test('should format timestamp date in digital format', () => {
+			const timestamp = 1705314600;
+			const result = TimestampUnix.getDateDigitalDisplay(timestamp, 'fr-FR', 'UTC');
+			expect(result).toContain('15');
+			expect(result).toContain('01');
+			expect(result).toContain('2024');
+		});
+	});
+
+	describe('getDateTextDisplay', () => {
+		test('should format timestamp date in text format', () => {
+			const timestamp = 1705314600;
+			const result = TimestampUnix.getDateTextDisplay(timestamp, 'fr-FR', 'UTC');
+			expect(typeof result).toBe('string');
+			expect(result.length).toBeGreaterThan(10);
+		});
+	});
+
+	describe('getTimeDisplay', () => {
+		test('should format timestamp time', () => {
+			const timestamp = 1705314600;
+			const result = TimestampUnix.getTimeDisplay(timestamp, 'fr-FR', 'UTC');
+			expect(result).toContain('10');
+			expect(result).toContain('30');
+		});
+	});
+
+	describe('getTimeDisplayWithNbDays', () => {
+		test('should display time without days difference', () => {
+			const timestamp = 1705314600;
+			const result = TimestampUnix.getTimeDisplayWithNbDays(timestamp, 0, 'fr-FR', 'UTC');
+			expect(result).toContain('10');
+			expect(result).toContain('30');
+		});
+
+		test('should display time with days difference', () => {
+			const timestamp1 = 1705315800; // 2024-01-15 10:30:00
+			const timestamp2 = 1705574400; // 2024-01-18 10:00:00
+			const result = TimestampUnix.getTimeDisplayWithNbDays(timestamp2, timestamp1, 'fr-FR', 'UTC');
+			expect(result).toContain('J+');
+		});
+	});
+
+	describe('getTimeDigitalDisplay', () => {
+		test('should format timestamp time in digital format', () => {
+			const timestamp = 1705314600;
+			const result = TimestampUnix.getTimeDigitalDisplay(timestamp, 'fr-FR', 'UTC');
+			expect(result).toMatch(/\d{2}:\d{2}:\d{2}/);
+		});
+	});
+
+	describe('getYear', () => {
+		test('should return year from timestamp', () => {
+			const timestamp = 1705314600;
+			const result = TimestampUnix.getYear(timestamp, 'UTC');
+			expect(result).toBe(2024);
+		});
+	});
+
+	describe('getMonth', () => {
+		test('should return month from timestamp', () => {
+			const timestamp = 1705314600;
+			const result = TimestampUnix.getMonth(timestamp, 'UTC');
+			expect(result).toBe(1);
+		});
+	});
+
+	describe('getDayOfMonth', () => {
+		test('should return day of month from timestamp', () => {
+			const timestamp = 1705314600;
+			const result = TimestampUnix.getDayOfMonth(timestamp, 'UTC');
+			expect(result).toBe(15);
+		});
+	});
+
+	describe('getHour', () => {
+		test('should return hour from timestamp', () => {
+			const timestamp = 1705314600;
+			const result = TimestampUnix.getHour(timestamp, 'UTC');
+			expect(result).toBe(10);
+		});
+	});
+
+	describe('getMinute', () => {
+		test('should return minute from timestamp', () => {
+			const timestamp = 1705314600;
+			const result = TimestampUnix.getMinute(timestamp, 'UTC');
+			expect(result).toBe(30);
+		});
+	});
+
+	describe('getSecond', () => {
+		test('should return second from timestamp', () => {
+			const timestamp = 1705314600;
+			const result = TimestampUnix.getSecond(timestamp, 'UTC');
+			expect(result).toBe(0);
+		});
+
+		test('should return 45 seconds', () => {
+			const timestamp = 1705315845;
+			const result = TimestampUnix.getSecond(timestamp, 'UTC');
+			expect(result).toBe(45);
+		});
+	});
+
+	describe('getSqlDateTime', () => {
+		test('should convert timestamp to SQL datetime', () => {
+			const timestamp = 1705314600;
+			const result = TimestampUnix.getSqlDateTime(timestamp, 'UTC');
+			expect(result).toMatch(/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/);
+		});
+	});
+
+	describe('getSqlDate', () => {
+		test('should convert timestamp to SQL date', () => {
+			const timestamp = 1705314600;
+			const result = TimestampUnix.getSqlDate(timestamp, 'UTC');
+			expect(result).toBe('2024-01-15');
+		});
+	});
+
+	describe('getSqlTime', () => {
+		test('should convert timestamp to SQL time', () => {
+			const timestamp = 1705314600;
+			const result = TimestampUnix.getSqlTime(timestamp, 'UTC');
+			expect(result).toBe('10:30:00');
+		});
+	});
+
+	describe('getDateForInputDate', () => {
+		test('should return date for input field', () => {
+			const timestamp = 1705314600;
+			const result = TimestampUnix.getDateForInputDate(timestamp, 'UTC');
+			expect(result).toBe('2024-01-15');
+		});
+	});
+
+	describe('getTimeForInputTime', () => {
+		test('should return time for input field without seconds', () => {
+			const timestamp = 1705314600;
+			const result = TimestampUnix.getTimeForInputTime(timestamp, 'UTC', false);
+			expect(result).toMatch(/^\d{2}:\d{2}$/);
+		});
+
+		test('should return time for input field with seconds', () => {
+			const timestamp = 1705314600;
+			const result = TimestampUnix.getTimeForInputTime(timestamp, 'UTC', true);
+			expect(result).toMatch(/^\d{2}:\d{2}:\d{2}$/);
+		});
+	});
+
+	describe('isDateEqual', () => {
+		test('should return true for timestamps on same date', () => {
+			const timestamp1 = 1705315800; // 2024-01-15 10:30:00
+			const timestamp2 = 1705329600; // 2024-01-15 14:20:00
+			expect(TimestampUnix.isDateEqual(timestamp1, timestamp2)).toBe(true);
+		});
+
+		test('should return false for timestamps on different dates', () => {
+			const timestamp1 = 1705315800; // 2024-01-15
+			const timestamp2 = 1705402200; // 2024-01-16
+			expect(TimestampUnix.isDateEqual(timestamp1, timestamp2)).toBe(false);
+		});
+	});
+
+	describe('getNbDayBetweenTwo', () => {
+		test('should calculate days between two timestamps', () => {
+			const timestamp1 = 1705315800; // 2024-01-15 10:30:00
+			const timestamp2 = 1705747800; // 2024-01-20 10:30:00
+			expect(TimestampUnix.getNbDayBetweenTwo(timestamp1, timestamp2, true, 'UTC')).toBe(5);
+		});
+
+		test('should return 0 for same day', () => {
+			const timestamp1 = 1705315800; // 2024-01-15 10:30:00
+			const timestamp2 = 1705329600; // 2024-01-15 14:20:00
+			expect(TimestampUnix.getNbDayBetweenTwo(timestamp1, timestamp2, false, 'UTC')).toBe(0);
+		});
+	});
+
+	describe('isDateInThePast', () => {
+		test('should return true for past timestamp', () => {
+			const timestamp = 1577836800; // 2020-01-01
+			expect(TimestampUnix.isDateInThePast(timestamp)).toBe(true);
+		});
+
+		test('should return false for future timestamp', () => {
+			const timestamp = 1893456000; // 2030-01-01
+			expect(TimestampUnix.isDateInThePast(timestamp)).toBe(false);
+		});
+	});
+
+	describe('isDateTimeInThePast', () => {
+		test('should return true for past timestamp', () => {
+			const timestamp = 1577836800; // 2020-01-01
+			expect(TimestampUnix.isDateTimeInThePast(timestamp)).toBe(true);
+		});
+
+		test('should return false for future timestamp', () => {
+			const timestamp = 1893456000; // 2030-01-01
+			expect(TimestampUnix.isDateTimeInThePast(timestamp)).toBe(false);
+		});
+	});
+
+	describe('isDateInTheFuture', () => {
+		test('should return true for future timestamp', () => {
+			const timestamp = 1893456000; // 2030-01-01
+			expect(TimestampUnix.isDateInTheFuture(timestamp)).toBe(true);
+		});
+
+		test('should return false for past timestamp', () => {
+			const timestamp = 1577836800; // 2020-01-01
+			expect(TimestampUnix.isDateInTheFuture(timestamp)).toBe(false);
+		});
+	});
+
+	describe('isDateTimeInTheFuture', () => {
+		test('should return true for future timestamp', () => {
+			const timestamp = 1893456000; // 2030-01-01
+			expect(TimestampUnix.isDateTimeInTheFuture(timestamp)).toBe(true);
+		});
+
+		test('should return false for past timestamp', () => {
+			const timestamp = 1577836800; // 2020-01-01
+			expect(TimestampUnix.isDateTimeInTheFuture(timestamp)).toBe(false);
+		});
+	});
+});

package/tests/details_sub_array.test.js

@@ -0,0 +1,367 @@
+/**
+ * @jest-environment jsdom
+ */
+const { DetailsSubArray } = require('../details_sub_array');
+
+// Mock HTTPClient
+jest.mock('../http_client', () => ({
+	HTTPClient: {
+		request: jest.fn()
+	}
+}));
+
+const { HTTPClient } = require('../http_client');
+
+describe('DetailsSubArray', () => {
+	let mockTable;
+	let mockLink;
+	let mockTr;
+	let mockThead;
+
+	beforeEach(() => {
+		// Clear all mocks
+		jest.clearAllMocks();
+
+		// Define global labels used by the code
+		global.showDetailsLabel = 'Show details';
+		global.hideDetailsLabel = 'Hide details';
+		global.labelErrorOccured = 'An error occurred';
+
+		// Make HTTPClient available globally
+		global.HTTPClient = HTTPClient;
+
+		// Create mock DOM structure
+		mockThead = {
+			find: jest.fn((selector) => {
+				if (selector === 'thead tr') {
+					return {
+						children: jest.fn(() => ({ length: 5 }))
+					};
+				}
+				return {
+					children: jest.fn(() => ({ length: 5 }))
+				};
+			})
+		};
+
+		mockTr = {
+			closest: jest.fn((selector) => {
+				if (selector === 'table') {
+					return {
+						find: jest.fn((sel) => {
+							if (sel === 'thead tr') {
+								return {
+									children: jest.fn(() => ({ length: 5 }))
+								};
+							}
+							return mockThead;
+						})
+					};
+				}
+				return mockTr;
+			}),
+			after: jest.fn(),
+			addClass: jest.fn().mockReturnThis(),
+			next: jest.fn(() => ({
+				hasClass: jest.fn(() => false),
+				remove: jest.fn()
+			}))
+		};
+
+		mockLink = {
+			data: jest.fn((key) => {
+				if (key === 'url_details') return 'http://example.com/details';
+				return null;
+			}),
+			closest: jest.fn(() => mockTr),
+			prop: jest.fn().mockReturnThis(),
+			attr: jest.fn().mockReturnThis(),
+			html: jest.fn().mockReturnThis(),
+			click: jest.fn().mockReturnThis(),
+			stop: jest.fn().mockReturnThis(),
+			off: jest.fn().mockReturnThis(),
+			removeClass: jest.fn().mockReturnThis()
+		};
+
+		mockTable = {
+			find: jest.fn(() => ({
+				each: jest.fn((callback) => {
+					// Simulate one link found
+					callback(0, mockLink);
+				})
+			}))
+		};
+
+		// Mock jQuery
+		global.$ = jest.fn((selector) => {
+			if (typeof selector === 'string') {
+				if (selector.includes('<tr')) {
+					return {
+						find: jest.fn().mockReturnThis(),
+						append: jest.fn().mockReturnThis(),
+						after: jest.fn().mockReturnThis()
+					};
+				}
+				if (selector.includes('<span')) {
+					return selector; // Return the HTML string for glyphicon
+				}
+				if (selector.includes('<i')) {
+					return selector; // Return the HTML string for fa icons
+				}
+				return {
+					length: 0,
+					remove: jest.fn()
+				};
+			}
+			// Wrap element
+			return selector;
+		});
+	});
+
+	afterEach(() => {
+		delete global.$;
+		delete global.showDetailsLabel;
+		delete global.hideDetailsLabel;
+		delete global.labelErrorOccured;
+		delete global.HTTPClient;
+	});
+
+	describe('initDetailsLink', () => {
+		test('should initialize details links', () => {
+			DetailsSubArray.initDetailsLink(mockTable);
+
+			expect(mockTable.find).toHaveBeenCalledWith('a.details_link');
+			expect(mockLink.removeClass).toHaveBeenCalledWith('hide');
+		});
+
+		test('should set up click handlers on links', () => {
+			DetailsSubArray.initDetailsLink(mockTable);
+
+			expect(mockLink.click).toHaveBeenCalled();
+		});
+
+		test('should show plus button initially', () => {
+			DetailsSubArray.initDetailsLink(mockTable);
+
+			expect(mockLink.html).toHaveBeenCalled();
+		});
+
+		test('should handle callback before send', () => {
+			const beforeSendCallback = jest.fn(() => '<div>Custom content</div>');
+
+			DetailsSubArray.initDetailsLink(mockTable, null, null, beforeSendCallback);
+
+			// Trigger the click
+			const clickHandler = mockLink.click.mock.calls[0][0];
+			if (clickHandler) {
+				clickHandler.call(mockLink);
+			}
+
+			// beforeSendCallback should be called when clicking
+			// (This tests that the callback is properly wired up)
+		});
+
+		test('should handle success callback', () => {
+			const successCallback = jest.fn((jsonObj, link) => '<div>Success</div>');
+
+			DetailsSubArray.initDetailsLink(mockTable, successCallback);
+
+			// Verify the callback is passed through
+			expect(mockTable.find).toHaveBeenCalled();
+		});
+
+		test('should handle error callback', () => {
+			const errorCallback = jest.fn();
+
+			DetailsSubArray.initDetailsLink(mockTable, null, errorCallback);
+
+			// Verify the callback is passed through
+			expect(mockTable.find).toHaveBeenCalled();
+		});
+
+		test('should make HTTP request when link is clicked', () => {
+			HTTPClient.request.mockImplementation((method, url, data, successCb, errorCb) => {
+				successCb({ data: 'test' });
+			});
+
+			const successCallback = jest.fn(() => '<div>Details</div>');
+			DetailsSubArray.initDetailsLink(mockTable, successCallback);
+
+			// Simulate click
+			const clickHandler = mockLink.click.mock.calls[0][0];
+			if (clickHandler) {
+				clickHandler.call(mockLink);
+			}
+
+			// HTTPClient.request should be called
+			expect(HTTPClient.request).toHaveBeenCalledWith(
+				'GET',
+				'http://example.com/details',
+				null,
+				expect.any(Function),
+				expect.any(Function)
+			);
+		});
+
+		test('should handle HTTP request success with null response', () => {
+			HTTPClient.request.mockImplementation((method, url, data, successCb) => {
+				successCb(null);
+			});
+
+			DetailsSubArray.initDetailsLink(mockTable);
+
+			// Simulate click
+			const clickHandler = mockLink.click.mock.calls[0][0];
+			if (clickHandler) {
+				clickHandler.call(mockLink);
+			}
+
+			// Should display error row
+			expect(mockTr.after).toHaveBeenCalled();
+		});
+
+		test('should handle HTTP request error', () => {
+			HTTPClient.request.mockImplementation((method, url, data, successCb, errorCb) => {
+				errorCb();
+			});
+
+			DetailsSubArray.initDetailsLink(mockTable);
+
+			// Simulate click
+			const clickHandler = mockLink.click.mock.calls[0][0];
+			if (clickHandler) {
+				clickHandler.call(mockLink);
+			}
+
+			// Should display error row
+			expect(mockTr.after).toHaveBeenCalled();
+		});
+
+		test('should call success callback with JSON response', () => {
+			const jsonResponse = { items: ['item1', 'item2'] };
+			const successCallback = jest.fn(() => '<div>Details</div>');
+
+			HTTPClient.request.mockImplementation((method, url, data, successCb) => {
+				successCb(jsonResponse);
+			});
+
+			DetailsSubArray.initDetailsLink(mockTable, successCallback);
+
+			// Simulate click
+			const clickHandler = mockLink.click.mock.calls[0][0];
+			if (clickHandler) {
+				clickHandler.call(mockLink);
+			}
+
+			// Success callback should be called with JSON response
+			expect(successCallback).toHaveBeenCalledWith(jsonResponse, mockLink);
+		});
+
+		test('should call error callback on HTTP error', () => {
+			const errorCallback = jest.fn();
+
+			HTTPClient.request.mockImplementation((method, url, data, successCb, errorCb) => {
+				errorCb();
+			});
+
+			DetailsSubArray.initDetailsLink(mockTable, null, errorCallback);
+
+			// Simulate click
+			const clickHandler = mockLink.click.mock.calls[0][0];
+			if (clickHandler) {
+				clickHandler.call(mockLink);
+			}
+
+			// Error callback should be called
+			expect(errorCallback).toHaveBeenCalledWith(mockLink);
+		});
+
+		test('should call error callback when response is null', () => {
+			const errorCallback = jest.fn();
+
+			HTTPClient.request.mockImplementation((method, url, data, successCb) => {
+				successCb(null);
+			});
+
+			DetailsSubArray.initDetailsLink(mockTable, null, errorCallback);
+
+			// Simulate click
+			const clickHandler = mockLink.click.mock.calls[0][0];
+			if (clickHandler) {
+				clickHandler.call(mockLink);
+			}
+
+			// Error callback should be called
+			expect(errorCallback).toHaveBeenCalledWith(mockLink);
+		});
+
+		test('should use before send callback instead of HTTP request', () => {
+			const beforeSendCallback = jest.fn(() => '<div>Immediate content</div>');
+
+			DetailsSubArray.initDetailsLink(mockTable, null, null, beforeSendCallback);
+
+			// Simulate click
+			const clickHandler = mockLink.click.mock.calls[0][0];
+			if (clickHandler) {
+				clickHandler.call(mockLink);
+			}
+
+			// Before send callback should be called
+			expect(beforeSendCallback).toHaveBeenCalledWith(mockLink);
+
+			// HTTP request should NOT be made
+			expect(HTTPClient.request).not.toHaveBeenCalled();
+		});
+
+		test('should handle multiple links', () => {
+			const mockLink2 = { ...mockLink };
+
+			mockTable.find = jest.fn(() => ({
+				each: jest.fn((callback) => {
+					callback(0, mockLink);
+					callback(1, mockLink2);
+				})
+			}));
+
+			DetailsSubArray.initDetailsLink(mockTable);
+
+			// Both links should be initialized
+			expect(mockLink.removeClass).toHaveBeenCalled();
+		});
+
+		test('should disable link while loading', () => {
+			HTTPClient.request.mockImplementation(() => {
+				// Don't call callbacks, simulate loading state
+			});
+
+			DetailsSubArray.initDetailsLink(mockTable);
+
+			// Simulate click
+			const clickHandler = mockLink.click.mock.calls[0][0];
+			if (clickHandler) {
+				clickHandler.call(mockLink);
+			}
+
+			// Link should be disabled during loading
+			expect(mockLink.attr).toHaveBeenCalledWith('disabled', true);
+		});
+
+		test('should show loading icon', () => {
+			HTTPClient.request.mockImplementation(() => {
+				// Loading state
+			});
+
+			DetailsSubArray.initDetailsLink(mockTable);
+
+			// Simulate click
+			const clickHandler = mockLink.click.mock.calls[0][0];
+			if (clickHandler) {
+				clickHandler.call(mockLink);
+			}
+
+			// Should display loading icon
+			expect(mockLink.html).toHaveBeenCalled();
+			expect(mockTr.after).toHaveBeenCalled();
+		});
+	});
+});