@seniorsistemas/hcm-clocking-event-rule-nodejs 0.35.0

package/src/test/utils/date.utils.spec.ts

@@ -0,0 +1,198 @@
+import { DateUtils, WeekDay } from '../../utils/dateUtils';
+
+const DATE_2025_03_04 = new Date('2025-03-04T00:00:00Z');
+
+describe('DateUtils', () => {
+  it('should return the correct difference in minutes between two dates', () => {
+    const start = DATE_2025_03_04;
+    const end = new Date('2025-03-04T01:00:00Z');
+    expect(DateUtils.getDateInMinutes(start, end)).toBe(60);
+  });
+
+  it('should create a date from year, month, and day', () => {
+    const date = DateUtils.of(2025, 3, 4);
+    expect(date.toISOString()).toBe('2025-03-04T00:00:00.000Z');
+  });
+
+  it('should format a date string to a Date object', () => {
+    const date = DateUtils.strIsoDateToDate('2025-03-04');
+    expect(date.toISOString()).toBe('2025-03-04T00:00:00.000Z');
+  });
+
+  it('should format a date string to a Date object', () => {
+    const date = DateUtils.dateToIsoDateStr(DateUtils.of(2025, 3, 4));
+    expect(date).toBe('2025-03-04');
+  });
+
+  it('should return true if one date is before another', () => {
+    const oneDate = new Date('2025-03-03T00:00:00Z');
+    const otherDate = DATE_2025_03_04;
+    expect(DateUtils.isBefore(oneDate, otherDate)).toBe(true);
+  });
+
+  it('should return true if one date is before or equal to another', () => {
+    const oneDate = DATE_2025_03_04;
+    const otherDate = DATE_2025_03_04;
+    expect(DateUtils.isBeforeOrEquals(oneDate, otherDate)).toBe(true);
+  });
+
+  it('should return true if one date is after another', () => {
+    const oneDate = new Date('2025-03-07T00:00:00Z');
+    const otherDate = DATE_2025_03_04;
+    expect(DateUtils.isAfter(oneDate, otherDate)).toBe(true);
+  });
+
+  it('should return true if one date is after or equal to another', () => {
+    const oneDate = DATE_2025_03_04;
+    const otherDate = DATE_2025_03_04;
+    expect(DateUtils.isAfterOrEquals(oneDate, otherDate)).toBe(true);
+  });
+
+  it('should compare two dates correctly', () => {
+    const oneDate = new Date('2025-03-03T00:00:00Z');
+    const otherDate = new Date('2025-03-06T00:00:00Z');
+    expect(DateUtils.compareTo(oneDate, otherDate)).toBeLessThan(0);
+  });
+
+  it('should return true if a date is between two other dates', () => {
+    const date = new Date('2025-03-04T12:00:00Z');
+    const start = DATE_2025_03_04;
+    const end = new Date('2025-03-05T00:00:00Z');
+    expect(DateUtils.between(date, start, end)).toBe(true);
+  });
+
+  it('should return true if two dates are equal', () => {
+    const oneDate = DATE_2025_03_04;
+    const otherDate = DATE_2025_03_04;
+    expect(DateUtils.equals(oneDate, otherDate)).toBe(true);
+  });
+
+  it('should return 30 minutos os diff', () => {
+    const date1 = new Date("2024-04-01T10:00:00Z");
+    const date2 = new Date("2024-04-01T10:30:00Z");
+    expect(DateUtils.getDateInMinutes(date1, date2)).toBe(30);
+  });
+
+  it("of should create correct date", () => {
+    const date = DateUtils.of(2024, 4, 1);
+    expect(date.toISOString()).toBe("2024-04-01T00:00:00.000Z");
+  });
+
+  it("isoDate should parse date correctly", () => {
+    const date = DateUtils.strIsoDateToDate("2024-04-01");
+    expect(date.toISOString()).toBe("2024-04-01T00:00:00.000Z");
+  });
+
+  it("isBefore should return true if first date is before second", () => {
+    expect(DateUtils.isBefore(new Date("2024-04-01"), new Date("2024-04-02"))).toBe(true);
+  });
+
+  it("getWeekDay should return correct weekday", () => {
+    const date = new Date("2025-04-01"); // TUESDAY
+    expect(DateUtils.getWeekDay(date)).toBe(WeekDay.TUESDAY);
+  });
+
+  it("getNumberOfDaysInMonth should return correct days count Fev", () => {
+    expect(DateUtils.getNumberOfDaysInMonth(new Date("2024-02-01"))).toBe(29); // Leap year
+  });
+
+  it("getNumberOfDaysInMonth should return correct days count", () => {
+    expect(DateUtils.getNumberOfDaysInMonth(new Date("2024-01-09"))).toBe(31); // Leap year
+  });
+
+  it("addMinutes should add correct minutes", () => {
+    const date = new Date("2024-04-01T10:00:00Z");
+    expect(DateUtils.addMinutes(date, 30).toISOString()).toBe("2024-04-01T10:30:00.000Z");
+  });
+
+  it("addMinutes should add correct minutes - next day", () => {
+    const date = new Date("2024-04-01T23:59:00Z");
+    expect(DateUtils.addMinutes(date, 30).toISOString()).toBe("2024-04-02T00:29:00.000Z");
+  });
+
+  it("subMinutes should subtract correct minutes", () => {
+    const date = new Date("2024-04-01T10:00:00Z");
+    expect(DateUtils.subMinutes(date, 30).toISOString()).toBe("2024-04-01T09:30:00.000Z");
+  });
+
+  it("subMinutes should subtract correct minutes - previews day", () => {
+    const date = new Date("2024-04-03T00:10:00Z");
+    expect(DateUtils.subMinutes(date, 30).toISOString()).toBe("2024-04-02T23:40:00.000Z");
+  });
+
+  it("days should return correct difference in days", () => {
+    const date1 = new Date("2024-04-01");
+    const date2 = new Date("2024-04-11");
+    expect(DateUtils.days(date1, date2)).toBe(10);
+  });
+
+  it("days should return correct difference in days- same day", () => {
+    const date1 = new Date("2024-04-01");
+    const date2 = new Date("2024-04-01");
+    expect(DateUtils.days(date1, date2)).toBe(0);
+  });
+
+
+  it("days should return correct difference in days- same day", () => {
+    const date1 = new Date("2024-04-02");
+    const date2 = new Date("2024-04-01");
+    expect(DateUtils.days(date1, date2)).toBe(-1);
+  });
+
+
+  it("days should return correct day of month", () => {
+    const date1 = new Date("2024-04-02");
+    expect(DateUtils.getDay(date1)).toBe(2);
+  });
+
+  it("days should return correct day of month - 31", () => {
+    const date1 = new Date("2024-01-31");
+    expect(DateUtils.getDay(date1)).toBe(31);
+  });
+
+  it("Month should return correct day of month - Janeiro = 1", () => {
+    const date1 = new Date("2024-01-31");
+    expect(DateUtils.getMonth(date1)).toBe(1);
+  });
+  
+  it("Month should return correct day of month - Dezembro = 12", () => {
+    const date1 = new Date("2024-12-31");
+    expect(DateUtils.getMonth(date1)).toBe(12);
+  });
+
+  it("Year should return correct year ", () => {
+    const date1 = new Date("2024-12-31");
+    expect(DateUtils.getYear(date1)).toBe(2024);
+  });
+
+
+  it("should return last day 29 ", () => {
+    const date1 = new Date("2024-02-10");
+    expect(DateUtils.getLastDayOfMonth(date1).toISOString()).toBe("2024-02-29T00:00:00.000Z");
+  });
+
+  it("should return last day 30 ", () => {
+    const date1 = new Date("2025-07-10");
+    expect(DateUtils.getLastDayOfMonth(date1).toISOString()).toBe("2025-07-31T00:00:00.000Z");
+  });
+});
+
+describe('DateUtils.format', () => {
+  it('deve formatar a data no formato dd/MM/yyyy', () => {
+      const date = new Date('2025-04-08T00:00:00Z');
+      const formattedDate = DateUtils.format(date);
+      expect(formattedDate).toBe('08/04/2025');
+  });
+
+  it('deve formatar corretamente uma data com dia e mês de um dígito', () => {
+      const date = new Date('2025-01-05T00:00:00Z');
+      const formattedDate = DateUtils.format(date);
+      expect(formattedDate).toBe('05/01/2025');
+  });
+
+  it('deve formatar corretamente uma data no final do ano', () => {
+      const date = new Date('2025-12-31T00:00:00Z');
+      const formattedDate = DateUtils.format(date);
+      expect(formattedDate).toBe('31/12/2025');
+  });
+});

package/src/test/utils/dateIntervalUtils.spec.ts

@@ -0,0 +1,210 @@
+import { DateInterval, DateIntervalUtils } from "../../utils/dateIntervalUtils";
+
+describe("DateIntervalsUtils", () => {
+    describe("isBeforeOrEquals", () => {
+        it("should return true if interval ends before comparedInterval starts", () => {
+            const a = new DateInterval(new Date("2023-01-01T00:00:00.000Z"), new Date("2023-01-02T00:00:00.000Z"));
+            const b = new DateInterval(new Date("2023-01-03T00:00:00.000Z"), new Date("2023-01-04T00:00:00.000Z"));
+            expect(DateIntervalUtils.isBeforeOrEquals(a, b)).toBe(true);
+        });
+        it("should return false if interval ends after comparedInterval starts", () => {
+            const a = new DateInterval(new Date("2023-01-03T00:00:00.000Z"), new Date("2023-01-05T00:00:00.000Z"));
+            const b = new DateInterval(new Date("2023-01-02T00:00:00.000Z"), new Date("2023-01-04T00:00:00.000Z"));
+            expect(DateIntervalUtils.isBeforeOrEquals(a, b)).toBe(false);
+        });
+        it("should return true if interval ends before comparedInterval starts with Time equals", () => {
+            const a = new DateInterval(new Date("2023-01-01T08:00:00.000Z"), new Date("2023-01-01T12:00:00.000Z"));
+            const b = new DateInterval(new Date("2023-01-01T12:00:00.000Z"), new Date("2023-01-04T13:30:00.000Z"));
+            expect(DateIntervalUtils.isBeforeOrEquals(a, b)).toBe(true);
+        });
+
+        it("should return true if interval ends before comparedInterval starts with Time", () => {
+            const a = new DateInterval(new Date("2023-01-01T08:00:00.000Z"), new Date("2023-01-01T12:00:00.000Z"));
+            const b = new DateInterval(new Date("2023-01-01T12:01:00.000Z"), new Date("2023-01-04T13:30:00.000Z"));
+            expect(DateIntervalUtils.isBeforeOrEquals(a, b)).toBe(true);
+        });
+
+        it("should return false if interval ends after comparedInterval starts with time", () => {
+            const a = new DateInterval(new Date("2023-01-01T12:00:00.000Z"), new Date("2023-01-01T13:00:00.000Z"));
+            const b = new DateInterval(new Date("2023-01-01T11:00:00.000Z"), new Date("2023-01-01T11:59:00.000Z"));
+            expect(DateIntervalUtils.isBeforeOrEquals(a, b)).toBe(false);
+        });
+    });
+
+    describe("isAfterOrEquals", () => {
+        it("should return true if interval starts after comparedInterval ends", () => {
+            const a = new DateInterval(new Date("2023-01-05T00:00:00.000Z"), new Date("2023-01-06T00:00:00.000Z"));
+            const b = new DateInterval(new Date("2023-01-01T00:00:00.000Z"), new Date("2023-01-04T00:00:00.000Z"));
+            expect(DateIntervalUtils.isAfterOrEquals(a, b)).toBe(true);
+        });
+        it("should return false if interval starts before comparedInterval ends", () => {
+            const a = new DateInterval(new Date("2023-01-01T00:00:00.000Z"), new Date("2023-01-03T00:00:00.000Z"));
+            const b = new DateInterval(new Date("2023-01-02T00:00:00.000Z"), new Date("2023-01-04T00:00:00.000Z"));
+            expect(DateIntervalUtils.isAfterOrEquals(a, b)).toBe(false);
+        });
+
+        it("should return true if interval starts after comparedInterval ends With time", () => {
+            const a = new DateInterval(new Date("2023-01-01T18:00:00.000Z"), new Date("2023-01-01T20:00:00.000Z"));
+            const b = new DateInterval(new Date("2023-01-01T13:30:00.000Z"), new Date("2023-01-01T18:00:00.000Z"));
+            expect(DateIntervalUtils.isAfterOrEquals(a, b)).toBe(true);
+        });
+        it("should return false if interval starts before comparedInterval ends with time", () => {
+            const a = new DateInterval(new Date("2023-01-01T13:30:00.000Z"), new Date("2023-01-01T18:00:00.000Z"));
+            const b = new DateInterval(new Date("2023-01-01T18:01:00.000Z"), new Date("2023-01-01T20:00:00.000Z"));
+            expect(DateIntervalUtils.isAfterOrEquals(a, b)).toBe(false);
+        });
+    });
+
+    describe("overlaps", () => {
+        it("should return true if interval overlaps compareInterval", () => {
+            const a = new DateInterval(new Date("2023-01-01T00:00:00.000Z"), new Date("2023-01-10T00:00:00.000Z"));
+            const b = new DateInterval(new Date("2023-01-03T00:00:00.000Z"), new Date("2023-01-05T00:00:00.000Z"));
+            expect(DateIntervalUtils.overlaps(a, b)).toBe(true);
+        });
+        it("should return false if interval does not overlap compareInterval", () => {
+            const a = new DateInterval(new Date("2023-01-01T00:00:00.000Z"), new Date("2023-01-02T00:00:00.000Z"));
+            const b = new DateInterval(new Date("2023-01-03T00:00:00.000Z"), new Date("2023-01-04T00:00:00.000Z"));
+            expect(DateIntervalUtils.overlaps(a, b)).toBe(false);
+        });
+
+        it("should return false if interval does not overlap compareInterval with time", () => {
+            const a = new DateInterval(new Date("2023-01-01T08:00:00.000Z"), new Date("2023-01-01T12:00:00.000Z"));
+            const b = new DateInterval(new Date("2023-01-01T09:00:00.000Z"), new Date("2023-01-01T11:00:00.000Z"));
+            expect(DateIntervalUtils.overlaps(a, b)).toBe(true);
+        });
+
+        it("should return false if interval does not overlap compareInterval with time", () => {
+            const a = new DateInterval(new Date("2023-01-01T08:00:00.000Z"), new Date("2023-01-01T12:00:00.000Z"));
+            const b = new DateInterval(new Date("2023-01-01T08:00:00.000Z"), new Date("2023-01-01T12:00:00.000Z"));
+            expect(DateIntervalUtils.overlaps(a, b)).toBe(true);
+        });
+
+        it("should return false if interval does not overlap compareInterval with time", () => {
+            const a = new DateInterval(new Date("2023-01-01T08:00:00.000Z"), new Date("2023-01-01T12:00:00.000Z"));
+            const b = new DateInterval(new Date("2023-01-01T08:00:00.000Z"), new Date("2023-01-01T12:00:01.000Z"));
+            expect(DateIntervalUtils.overlaps(a, b)).toBe(false);
+        });
+    });
+
+    describe("into", () => {
+        it("should return true if interval is completely inside compareInterval", () => {
+            const a = new DateInterval(new Date("2023-01-03T00:00:00.000Z"), new Date("2023-01-05T00:00:00.000Z"));
+            const b = new DateInterval(new Date("2023-01-01T00:00:00.000Z"), new Date("2023-01-10T00:00:00.000Z"));
+            expect(DateIntervalUtils.into(a, b)).toBe(true);
+        });
+        it("should return false if interval is not inside compareInterval", () => {
+            const a = new DateInterval(new Date("2023-01-01T00:00:00.000Z"), new Date("2023-01-11T00:00:00.000Z"));
+            const b = new DateInterval(new Date("2023-01-03T00:00:00.000Z"), new Date("2023-01-10T00:00:00.000Z"));
+            expect(DateIntervalUtils.into(a, b)).toBe(false);
+        });
+
+
+        it("should return true if interval is completely inside compareInterval with timer", () => {
+            const a = new DateInterval(new Date("2023-01-01T00:00:00.000Z"), new Date("2023-01-01T00:00:00.000Z"));
+            const b = new DateInterval(new Date("2023-01-01T00:00:00.000Z"), new Date("2023-01-01T00:00:00.000Z"));
+            expect(DateIntervalUtils.into(a, b)).toBe(true);
+        });
+
+
+        it("should return true if interval is completely inside compareInterval", () => {
+            const a = new DateInterval(new Date("2023-01-01T12:00:00.000Z"), new Date("2023-01-01T13:30:00.000Z"));
+            const b = new DateInterval(new Date("2023-01-01T12:00:00.000Z"), new Date("2023-01-01T14:00:00.000Z"));
+            expect(DateIntervalUtils.into(a, b)).toBe(true);
+        });
+
+        it("should return true if interval is completely inside compareInterval", () => {
+            const a = new DateInterval(new Date("2023-01-01T12:00:00.000Z"), new Date("2023-01-01T13:30:00.000Z"));
+            const b = new DateInterval(new Date("2023-01-01T11:59:00.000Z"), new Date("2023-01-01T13:30:00.000Z"));
+            expect(DateIntervalUtils.into(a, b)).toBe(true);
+        });
+
+        it("should return true if interval is completely inside compareInterval", () => {
+            const a = new DateInterval(new Date("2023-01-01T13:00:00.000Z"), new Date("2023-01-01T13:00:00.000Z"));
+            const b = new DateInterval(new Date("2023-01-01T11:59:00.000Z"), new Date("2023-01-01T13:30:00.000Z"));
+            expect(DateIntervalUtils.into(a, b)).toBe(true);
+        });
+
+        it("should return true if interval is completely inside compareInterval", () => {
+            const a = new DateInterval(new Date("2023-01-01T11:59:00.000Z"), new Date("2023-01-01T13:30:00.000Z"));
+            const b = new DateInterval(new Date("2023-01-01T13:00:00.000Z"), new Date("2023-01-01T13:00:00.000Z"));
+            expect(DateIntervalUtils.into(a, b)).toBe(false);
+        });
+
+
+    });
+
+    describe("isOverStart", () => {
+        it("should return true if interval is over the start of compareInterval", () => {
+            const a = new DateInterval(new Date("2023-01-01T00:00:00.000Z"), new Date("2023-01-10T00:00:00.000Z"));
+            const b = new DateInterval(new Date("2023-01-05T00:00:00.000Z"), new Date("2023-01-12T00:00:00.000Z"));
+            expect(DateIntervalUtils.isOverStart(a, b)).toBe(true);
+        });
+        it("should return false if interval is not over the start of compareInterval", () => {
+            const a = new DateInterval(new Date("2023-01-10T00:00:00.000Z"), new Date("2023-01-12T00:00:00.000Z"));
+            const b = new DateInterval(new Date("2023-01-01T00:00:00.000Z"), new Date("2023-01-08T00:00:00.000Z"));
+            expect(DateIntervalUtils.isOverStart(a, b)).toBe(false);
+        });
+
+
+        it("should return true if interval is over the start of compareInterval with Time", () => {
+            const a = new DateInterval(new Date("2023-01-01T08:00:00.000Z"), new Date("2023-01-10T12:00:00.000Z"));
+            const b = new DateInterval(new Date("2023-01-10T11:59:00.000Z"), new Date("2023-01-12T13:00:00.000Z"));
+            expect(DateIntervalUtils.isOverStart(a, b)).toBe(true);
+        });
+
+        it("should return true if interval is over the start of compareInterval with Time", () => {
+            const a = new DateInterval(new Date("2023-01-01T08:00:00.000Z"), new Date("2023-01-10T12:00:00.000Z"));
+            const b = new DateInterval(new Date("2023-01-05T10:00:00.000Z"), new Date("2023-01-08T10:00:00.000Z"));
+            expect(DateIntervalUtils.isOverStart(a, b)).toBe(false);
+        });
+
+        it("should return true if interval is over the start of compareInterval with Time", () => {
+            const a = new DateInterval(new Date("2023-01-09T00:00:00.000Z"), new Date("2023-01-10T00:00:00.000Z"));
+            const b = new DateInterval(new Date("2023-01-05T00:00:00.000Z"), new Date("2023-01-08T00:00:00.000Z"));
+            expect(DateIntervalUtils.isOverStart(a, b)).toBe(false);
+        });
+
+        it("should return true if interval is over the start of compareInterval with Time", () => {
+            const a = new DateInterval(new Date("2023-01-01T10:00:00.000Z"), new Date("2023-01-01T11:00:00.000Z"));
+            const b = new DateInterval(new Date("2023-01-01T11:00:00.000Z"), new Date("2023-01-01T12:00:00.000Z"));
+            expect(DateIntervalUtils.isOverStart(a, b)).toBe(false);
+        });
+
+        it("should return true if interval is over the start of compareInterval with Time", () => {
+            const a = new DateInterval(new Date("2023-01-01T11:00:00.000Z"), new Date("2023-01-01T12:00:00.000Z"));
+            const b = new DateInterval(new Date("2023-01-01T11:00:00.000Z"), new Date("2023-01-01T13:00:00.000Z"));
+            expect(DateIntervalUtils.isOverStart(a, b)).toBe(true);
+        });
+    });
+
+    describe("isOverEnd", () => { 
+        it("should return true if interval is over the end of compareInterval", () => {
+            const a = new DateInterval(new Date("2023-01-05"), new Date("2023-01-12"));
+            const b = new DateInterval(new Date("2023-01-01"), new Date("2023-01-08"));
+            expect(DateIntervalUtils.isOverEnd(a, b)).toBe(true);
+        });
+        it("should return false if interval is not over the end of compareInterval", () => {
+            const a = new DateInterval(new Date("2023-01-01"), new Date("2023-01-05"));
+            const b = new DateInterval(new Date("2023-01-06"), new Date("2023-01-08"));
+            expect(DateIntervalUtils.isOverEnd(a, b)).toBe(false);
+        });
+
+        it("should return true if interval is over the end of compareInterval with time", () => {
+            const a = new DateInterval(new Date("2023-01-05T00:00:00.000Z"), new Date("2023-01-12T00:00:00.000Z"));
+            const b = new DateInterval(new Date("2023-01-01T00:00:00.000Z"), new Date("2023-01-08T00:00:00.000Z"));
+            expect(DateIntervalUtils.isOverEnd(a, b)).toBe(true);
+        });
+
+        it("should return true if interval is over the end of compareInterval with time", () => {
+            const a = new DateInterval(new Date("2023-01-01T08:00:00.000Z"), new Date("2023-01-01T12:00:00.000Z"));
+            const b = new DateInterval(new Date("2023-01-01T08:01:00.000Z"), new Date("2023-01-01T09:00:00.000Z"));
+            expect(DateIntervalUtils.isOverEnd(a, b)).toBe(false);
+        });
+
+        it("should return true if interval is over the end of compareInterval with time", () => {
+            const a = new DateInterval(new Date("2023-01-01T08:00:00.000Z"), new Date("2023-01-01T12:00:00.000Z"));
+            const b = new DateInterval(new Date("2023-01-01T07:59:00.000Z"), new Date("2023-01-01T09:00:00.000Z"));
+            expect(DateIntervalUtils.isOverEnd(a, b)).toBe(true);
+        });
+    });
+});

package/src/test/utils/object.utils.spec.ts

@@ -0,0 +1,83 @@
+import { ObjectUtils } from "../../utils/object.utils";
+
+describe("ObjectUtils", () => {
+  describe("isObjectEmpty", () => {
+    it("deve retornar true para objeto vazio", () => {
+      expect(ObjectUtils.isObjectEmpty({})).toBe(true);
+    });
+
+    it("deve retornar false para objeto com propriedades", () => {
+      expect(ObjectUtils.isObjectEmpty({ key: "value" })).toBe(false);
+    });
+
+  });
+
+  describe("isDateInstance", () => {
+    it("deve retornar true para instância válida de Date", () => {
+      expect(ObjectUtils.isDateInstance(new Date())).toBe(true);
+    });
+
+    it("deve retornar false para data inválida", () => {
+      expect(ObjectUtils.isDateInstance(new Date("invalid-date"))).toBe(false);
+    });
+
+    it("deve retornar false para string", () => {
+      expect(ObjectUtils.isDateInstance("2025-04-01")).toBe(false);
+    });
+  });
+
+  describe("toDateOrThrow", () => {
+    it("deve retornar a data se for uma instância válida de Date", () => {
+      const date = new Date("2025-04-02");
+      expect(ObjectUtils.toDateOrThrow(date)).toEqual(date);
+    });
+
+    it("deve converter string de data válida para Date", () => {
+      const date = ObjectUtils.toDateOrThrow("2025-04-02");
+      expect(date).toBeInstanceOf(Date);
+      expect(date.toISOString().startsWith("2025-04-02")).toBe(true);
+    });
+
+    it("deve lançar erro se valor for null", () => {
+      expect(() => ObjectUtils.toDateOrThrow(null)).toThrow(
+        'O campo "date" não é uma data válida: null'
+      );
+    });
+
+    it("deve lançar erro se string for inválida", () => {
+      expect(() => ObjectUtils.toDateOrThrow("data inválida")).toThrow();
+    });
+
+    it("deve lançar erro com nome de campo personalizado", () => {
+      expect(() => ObjectUtils.toDateOrThrow("abc", "nascimento")).toThrow(
+        'O campo "nascimento" não é uma data válida: abc'
+      );
+    });
+  });
+
+  describe("toDateOrNull", () => {
+    it("deve retornar a própria instância de Date válida", () => {
+      const date = new Date();
+      expect(ObjectUtils.toDateOrNull(date)).toEqual(date);
+    });
+
+    it("deve converter string de data válida para Date", () => {
+      const result = ObjectUtils.toDateOrNull("2025-04-02");
+      expect(result).toBeInstanceOf(Date);
+      expect(result!.toISOString().startsWith("2025-04-02")).toBe(true);
+    });
+
+    it("deve retornar null para string inválida", () => {
+      expect(ObjectUtils.toDateOrNull("abc")).toBeNull();
+    });
+
+    it("deve retornar null para null", () => {
+      expect(ObjectUtils.toDateOrNull(null)).toBeNull();
+    });
+
+    it("deve retornar null para tipos não suportados", () => {
+      expect(ObjectUtils.toDateOrNull({})).toBeNull();
+      expect(ObjectUtils.toDateOrNull(123)).toBeNull();
+    });
+  });
+});