@haskou/value-objects 1.0.1

package/tests/value-objects/time/CalendarDay.spec.ts

@@ -0,0 +1,182 @@
+import {
+  Timestamp,
+  CalendarDay,
+  InvalidDayError,
+  Month,
+  Day,
+  DayOfWeek,
+  Year,
+  InvalidDayFormatError,
+} from '../../../src';
+
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+describe('CalendarDay', () => {
+  describe('constructor', () => {
+    it('should create a CalendarDay ', () => {
+      const now = new Timestamp();
+      const day = new CalendarDay();
+      expect(day).toMatchObject({
+        year: now.getYear().valueOf(),
+        month: now.getMonth().valueOf(),
+        day: now.getDay().valueOf(),
+      });
+    });
+
+    it('should create a day instance with a valid date string', () => {
+      const day = new CalendarDay('2022-01-01');
+      expect(day).toMatchObject({
+        year: 2022,
+        month: 1,
+        day: 1,
+      });
+    });
+
+    it('should create a day instance with a valid Timestamp', () => {
+      const day = new CalendarDay(new Timestamp('2022-01-01'));
+      expect(day).toMatchObject({
+        year: 2022,
+        month: 1,
+        day: 1,
+      });
+    });
+
+    it('should create a day instance with a valid Date', () => {
+      const day = new CalendarDay(new Date('2022-01-01'));
+      expect(day).toMatchObject({
+        year: 2022,
+        month: 1,
+        day: 1,
+      });
+    });
+
+    it('should create a day instance with a valid number', () => {
+      const day = new CalendarDay(1640995200000);
+      expect(day).toMatchObject({
+        year: 2022,
+        month: 1,
+        day: 1,
+      });
+    });
+
+    it('should throw InvalidDateFormatError when provided with an invalid date string', () => {
+      expect(() => new CalendarDay('2022-01-001')).toThrow(
+        InvalidDayFormatError,
+      );
+    });
+
+    it('should throw InvalidDateFormatError when provided with an invalid date string', () => {
+      expect(() => new CalendarDay('2022-01')).toThrow(InvalidDayFormatError);
+    });
+
+    it('should throw InvalidDateFormatError when provided with an invalid date', () => {
+      expect(() => new CalendarDay(new Date(NaN))).toThrow(InvalidDayError);
+    });
+  });
+
+  describe('valueOf', () => {
+    it('should return the date value as a string', () => {
+      const day = new CalendarDay('2022-01-01');
+      expect(day.valueOf()).toBe('2022-01-01');
+    });
+  });
+
+  describe('isEqual', () => {
+    it('should return true when two days have the same value', () => {
+      const day1 = new CalendarDay('2022-01-01');
+      const day2 = new CalendarDay('2022-01-01');
+      expect(day1.isEqual(day2)).toBe(true);
+    });
+
+    it('should return false when two days have different values', () => {
+      const day1 = new CalendarDay('2022-01-01');
+      const day2 = new CalendarDay('2022-01-02');
+      expect(day1.isEqual(day2)).toBe(false);
+    });
+  });
+
+  describe('isAfter', () => {
+    it('should return true when the current day is after the provided day', () => {
+      const day1 = new CalendarDay('2022-01-02');
+      const day2 = new CalendarDay('2022-01-01');
+      expect(day1.isAfter(day2)).toBe(true);
+    });
+
+    it('should return false when the current day is not after the provided day', () => {
+      const day1 = new CalendarDay('2022-01-01');
+      const day2 = new CalendarDay('2022-01-02');
+      expect(day1.isAfter(day2)).toBe(false);
+    });
+  });
+
+  describe('isBefore', () => {
+    it('should return true when the current day is before the provided day', () => {
+      const day1 = new CalendarDay('2022-01-01');
+      const day2 = new CalendarDay('2022-01-02');
+      expect(day1.isBefore(day2)).toBe(true);
+    });
+
+    it('should return false when the current day is not before the provided day', () => {
+      const day1 = new CalendarDay('2022-01-02');
+      const day2 = new CalendarDay('2022-01-01');
+      expect(day1.isBefore(day2)).toBe(false);
+    });
+  });
+  describe('getYear', () => {
+    it('should return the year of the day', () => {
+      const day = new CalendarDay('2022-01-02');
+      expect(day.getYear()).toBe(2022);
+    });
+  });
+  describe('getMonth', () => {
+    it('should return the Month of the day', () => {
+      const day = new CalendarDay('2022-01-02');
+      expect(day.getMonth()).toStrictEqual(Month.JANUARY);
+    });
+  });
+  describe('getDay', () => {
+    it('should return the year of the day', () => {
+      const day = new CalendarDay('2022-01-02');
+      expect(day.getDay()).toStrictEqual(new Day(2));
+    });
+  });
+  describe('getDayOfWeek', () => {
+    it('should return the correct DayOfWeek for a given date', () => {
+      expect(new CalendarDay('2025-01-05').getDayOfWeek()).toEqual(
+        DayOfWeek.SUNDAY,
+      );
+      expect(new CalendarDay('2025-01-31').getDayOfWeek()).toEqual(
+        DayOfWeek.FRIDAY,
+      );
+      expect(new CalendarDay('2025-02-28').getDayOfWeek()).toEqual(
+        DayOfWeek.FRIDAY,
+      );
+      expect(new CalendarDay('2024-12-31').getDayOfWeek()).toEqual(
+        DayOfWeek.TUESDAY,
+      );
+    });
+
+    describe('toTimestamp', () => {
+      it('should return the correct Timestamp instance', () => {
+        const timestamp = new Timestamp('2022-01-01');
+        const day = new CalendarDay(timestamp);
+        expect(day.toTimestamp()).toStrictEqual(timestamp);
+      });
+
+      it('should return a Timestamp instance matching the date value', () => {
+        const day = new CalendarDay('2022-01-01');
+        const timestamp = day.toTimestamp();
+        expect(timestamp.valueOf()).toBe(new Timestamp('2022-01-01').valueOf());
+      });
+    });
+    describe('getMonthOfYear', () => {
+      it('should return a MonthOfYear instance with the correct month and year', () => {
+        const day = new CalendarDay('2022-01-02');
+        const month = day.getMonthOfYear();
+        expect(month).toMatchObject({
+          month: Month.JANUARY,
+          year: new Year(2022),
+        });
+      });
+    });
+  });
+});

package/tests/value-objects/time/Day.spec.ts

@@ -0,0 +1,29 @@
+import { Day, InvalidDayError, NumberValueObject } from '../../../src';
+
+describe('Day', () => {
+  it('should create a valid Day instance for a value within the valid range', () => {
+    expect(() => new Day(1)).not.toThrow();
+    expect(() => new Day(15)).not.toThrow();
+    expect(() => new Day(31)).not.toThrow();
+  });
+
+  it('should throw InvalidDayError for a value less than 1', () => {
+    expect(() => new Day(0)).toThrow(InvalidDayError);
+    expect(() => new Day(-1)).toThrow(InvalidDayError);
+  });
+
+  it('should throw InvalidDayError for a value greater than 31', () => {
+    expect(() => new Day(32)).toThrow(InvalidDayError);
+    expect(() => new Day(100)).toThrow(InvalidDayError);
+  });
+
+  it('should accept a NumberValueObject as input', () => {
+    expect(() => new Day(new NumberValueObject(3))).not.toThrow();
+  });
+  it('should be not equal to another Day with a different value', () => {
+    const day1 = new Day(1);
+    const day2 = new Day(2);
+    expect(day1.isEqual(day2)).toBe(false);
+    expect(day1.isNotEqual(day2)).toBe(true);
+  });
+});

package/tests/value-objects/time/DayOfWeek.spec.ts

@@ -0,0 +1,71 @@
+import { DayOfWeek, Timestamp, EDaysOfWeek } from '../../../src';
+
+describe('DayOfWeek', () => {
+  describe('fromNumber', () => {
+    it('should create the correct Day instance from a number', () => {
+      expect(
+        DayOfWeek.fromNumber(new Timestamp('2024-05-27').getDayOfWeek()),
+      ).toEqual(DayOfWeek.MONDAY);
+      expect(
+        DayOfWeek.fromNumber(new Timestamp('2024-05-28').getDayOfWeek()),
+      ).toEqual(DayOfWeek.TUESDAY);
+      expect(
+        DayOfWeek.fromNumber(new Timestamp('2024-05-29').getDayOfWeek()),
+      ).toEqual(DayOfWeek.WEDNESDAY);
+      expect(
+        DayOfWeek.fromNumber(new Timestamp('2024-05-30').getDayOfWeek()),
+      ).toEqual(DayOfWeek.THURSDAY);
+      expect(
+        DayOfWeek.fromNumber(new Timestamp('2024-05-31').getDayOfWeek()),
+      ).toEqual(DayOfWeek.FRIDAY);
+      expect(
+        DayOfWeek.fromNumber(new Timestamp('2024-06-01').getDayOfWeek()),
+      ).toEqual(DayOfWeek.SATURDAY);
+      expect(
+        DayOfWeek.fromNumber(new Timestamp('2024-06-02').getDayOfWeek()),
+      ).toEqual(DayOfWeek.SUNDAY);
+    });
+
+    it('should throw an error when an invalid number is provided', () => {
+      expect(() => {
+        DayOfWeek.fromNumber(23);
+      }).toThrow();
+    });
+  });
+  describe('toNumber', () => {
+    it('should return the correct number for a day', () => {
+      expect(DayOfWeek.MONDAY.toNumber()).toEqual(1);
+      expect(DayOfWeek.TUESDAY.toNumber()).toEqual(2);
+      expect(DayOfWeek.WEDNESDAY.toNumber()).toEqual(3);
+      expect(DayOfWeek.THURSDAY.toNumber()).toEqual(4);
+      expect(DayOfWeek.FRIDAY.toNumber()).toEqual(5);
+      expect(DayOfWeek.SATURDAY.toNumber()).toEqual(6);
+      expect(DayOfWeek.SUNDAY.toNumber()).toEqual(0);
+    });
+  });
+  describe('fromTimestamp', () => {
+    it('should create the correct Day instance from a timestamp', () => {
+      expect(DayOfWeek.fromTimestamp(new Timestamp('2024-05-27'))).toEqual(
+        DayOfWeek.MONDAY,
+      );
+      expect(DayOfWeek.fromTimestamp(new Timestamp('2024-05-28'))).toEqual(
+        DayOfWeek.TUESDAY,
+      );
+      expect(DayOfWeek.fromTimestamp(new Timestamp('2024-05-29'))).toEqual(
+        DayOfWeek.WEDNESDAY,
+      );
+      expect(DayOfWeek.fromTimestamp(new Timestamp('2024-05-30'))).toEqual(
+        DayOfWeek.THURSDAY,
+      );
+      expect(DayOfWeek.fromTimestamp(new Timestamp('2024-05-31'))).toEqual(
+        DayOfWeek.FRIDAY,
+      );
+      expect(DayOfWeek.fromTimestamp(new Timestamp('2024-06-01'))).toEqual(
+        DayOfWeek.SATURDAY,
+      );
+      expect(DayOfWeek.fromTimestamp(new Timestamp('2024-06-02'))).toEqual(
+        DayOfWeek.SUNDAY,
+      );
+    });
+  });
+});

package/tests/value-objects/time/Duration.spec.ts

@@ -0,0 +1,278 @@
+import { Duration } from '../../../src';
+
+describe('Duration', () => {
+  describe('fromDays', () => {
+    it('should create a Time instance from days', () => {
+      const days = 2;
+      const expectedMilliseconds = 2 * 24 * 60 * 60 * 1000;
+      const time = Duration.fromDays(days);
+      expect(time.valueOf()).toBe(expectedMilliseconds);
+    });
+  });
+
+  describe('fromHours', () => {
+    it('should create a Time instance from hours', () => {
+      const hours = 2;
+      const expectedMilliseconds = 2 * 60 * 60 * 1000;
+      const time = Duration.fromHours(hours);
+      expect(time.valueOf()).toBe(expectedMilliseconds);
+    });
+  });
+
+  describe('fromMinutes', () => {
+    it('should create a Time instance from minutes', () => {
+      const minutes = 30;
+      const expectedMilliseconds = 30 * 60 * 1000;
+      const time = Duration.fromMinutes(minutes);
+      expect(time.valueOf()).toBe(expectedMilliseconds);
+    });
+  });
+
+  describe('fromSeconds', () => {
+    it('should create a Time instance from seconds', () => {
+      const seconds = 45;
+      const expectedMilliseconds = 45 * 1000;
+      const time = Duration.fromSeconds(seconds);
+      expect(time.valueOf()).toBe(expectedMilliseconds);
+    });
+  });
+
+  describe('fromMilliseconds', () => {
+    it('should create a Time instance from milliseconds', () => {
+      const milliseconds = 500;
+      const time = Duration.fromMilliseconds(milliseconds);
+      expect(time.valueOf()).toBe(milliseconds);
+    });
+  });
+
+  describe('getTotalDays', () => {
+    it('should return the total days', () => {
+      const milliseconds = 2 * 24 * 60 * 60 * 1000;
+      const time = Duration.fromMilliseconds(milliseconds);
+      const totalDays = time.getTotalDays();
+      expect(totalDays.valueOf()).toBe(2);
+    });
+    it('should keep the value after getting it', () => {
+      const milliseconds = 2 * 24 * 60 * 60 * 1000;
+      const time = Duration.fromMilliseconds(milliseconds);
+      const firstTime = time.getTotalDays();
+      const secondTime = time.getTotalDays();
+
+      expect(firstTime.valueOf()).toBe(2);
+      expect(secondTime.valueOf()).toBe(2);
+    });
+  });
+
+  describe('getTotalHours', () => {
+    it('should return the total hours', () => {
+      const milliseconds = 2 * 60 * 60 * 1000;
+      const time = Duration.fromMilliseconds(milliseconds);
+      const totalHours = time.getTotalHours();
+      expect(totalHours.valueOf()).toBe(2);
+    });
+    it('should keep the value after getting it', () => {
+      const milliseconds = 2 * 60 * 60 * 1000;
+      const time = Duration.fromMilliseconds(milliseconds);
+      const firstTime = time.getTotalHours();
+      const secondTime = time.getTotalHours();
+
+      expect(firstTime.valueOf()).toBe(2);
+      expect(secondTime.valueOf()).toBe(2);
+    });
+  });
+
+  describe('getTotalMinutes', () => {
+    it('should return the total minutes', () => {
+      const milliseconds = 3000 * 60 * 1000;
+      const time = Duration.fromMilliseconds(milliseconds);
+      const totalMinutes = time.getTotalMinutes();
+      expect(totalMinutes.valueOf()).toBe(3000);
+    });
+    it('should keep the value after getting it', () => {
+      const milliseconds = 3000 * 60 * 1000;
+      const time = Duration.fromMilliseconds(milliseconds);
+      const firstTime = time.getTotalMinutes();
+      const secondTime = time.getTotalMinutes();
+
+      expect(firstTime.valueOf()).toBe(3000);
+      expect(secondTime.valueOf()).toBe(3000);
+    });
+  });
+
+  describe('getTotalSeconds', () => {
+    it('should return the total seconds', () => {
+      const milliseconds = 450 * 1000;
+      const time = Duration.fromMilliseconds(milliseconds);
+      const totalSeconds = time.getTotalSeconds();
+      expect(totalSeconds.valueOf()).toBe(450);
+    });
+    it('should keep the value after getting it', () => {
+      const milliseconds = 450 * 1000;
+      const time = Duration.fromMilliseconds(milliseconds);
+      const firstTime = time.getTotalSeconds();
+      const secondTime = time.getTotalSeconds();
+
+      expect(firstTime.valueOf()).toBe(450);
+      expect(secondTime.valueOf()).toBe(450);
+    });
+  });
+
+  describe('getTotalMilliseconds', () => {
+    it('should return the total milliseconds', () => {
+      const milliseconds = 5000000;
+      const time = Duration.fromMilliseconds(milliseconds);
+      const totalMilliseconds = time.getTotalMilliseconds();
+      expect(totalMilliseconds.valueOf()).toBe(milliseconds);
+    });
+    it('should return the total milliseconds', () => {
+      const milliseconds = 500;
+      const time = Duration.fromMilliseconds(milliseconds);
+      const totalMilliseconds = time.getTotalMilliseconds();
+      expect(totalMilliseconds.valueOf()).toBe(milliseconds);
+    });
+    it('should keep the value after getting it', () => {
+      const milliseconds = 3000 * 60 * 1000;
+      const time = Duration.fromMilliseconds(milliseconds);
+      const firstTime = time.getTotalMilliseconds();
+      const secondTime = time.getTotalMilliseconds();
+
+      expect(firstTime.valueOf()).toBe(milliseconds);
+      expect(secondTime.valueOf()).toBe(milliseconds);
+    });
+  });
+
+  describe('getDays', () => {
+    it('should return the days', () => {
+      const milliseconds = 2 * 24 * 60 * 60 * 1000;
+      const time = Duration.fromMilliseconds(milliseconds);
+      const days = time.getDays();
+      expect(days.valueOf()).toBe(2);
+    });
+    it('should return the days when there are hours and milliseconds', () => {
+      let milliseconds = 2 * 24 * 60 * 60 * 1000;
+      milliseconds += 2 * 60 * 60 * 1000;
+      const time = Duration.fromMilliseconds(milliseconds);
+      const days = time.getDays();
+      expect(days.valueOf()).toBe(2);
+    });
+    it('should return the days', () => {
+      const milliseconds = 976940000;
+      const time = Duration.fromMilliseconds(milliseconds);
+      const days = time.getDays();
+      expect(days.valueOf()).toBe(11);
+    });
+    it('should keep the value after getting it', () => {
+      const milliseconds = 976940000;
+      const time = Duration.fromMilliseconds(milliseconds);
+      const firstTime = time.getDays();
+      const secondTime = time.getDays();
+
+      expect(firstTime.valueOf()).toBe(11);
+      expect(secondTime.valueOf()).toBe(11);
+    });
+  });
+
+  describe('getHours', () => {
+    it('should return the hours', () => {
+      const milliseconds = 2 * 60 * 60 * 1000;
+      const time = Duration.fromMilliseconds(milliseconds);
+      const hours = time.getHours();
+      expect(hours.valueOf()).toBe(2);
+    });
+    it('should return the hours when there are minutes and milliseconds', () => {
+      let milliseconds = 2 * 60 * 60 * 1000;
+      milliseconds += 30 * 60 * 1000;
+      const time = Duration.fromMilliseconds(milliseconds);
+      const hours = time.getHours();
+      expect(hours.valueOf()).toBe(2);
+    });
+    it('should return the hours', () => {
+      const milliseconds = 35940000;
+      const time = Duration.fromMilliseconds(milliseconds);
+      const minutes = time.getHours();
+      expect(minutes.valueOf()).toBe(9);
+    });
+    it('should keep the value after getting it', () => {
+      const milliseconds = 35940000;
+      const time = Duration.fromMilliseconds(milliseconds);
+      const firstTime = time.getHours();
+      const secondTime = time.getHours();
+
+      expect(firstTime.valueOf()).toBe(9);
+      expect(secondTime.valueOf()).toBe(9);
+    });
+  });
+
+  describe('getMinutes', () => {
+    it('should return the minutes', () => {
+      const milliseconds = 30 * 60 * 1000;
+      const time = Duration.fromMilliseconds(milliseconds);
+      const minutes = time.getMinutes();
+      expect(minutes.valueOf()).toBe(30);
+    });
+    it('should return the minutes', () => {
+      const milliseconds = 35940000;
+      const time = Duration.fromMilliseconds(milliseconds);
+      const minutes = time.getMinutes();
+      expect(minutes.valueOf()).toBe(59);
+    });
+    it('should keep the value after getting it', () => {
+      const milliseconds = 35940000;
+      const time = Duration.fromMilliseconds(milliseconds);
+      const firstTime = time.getMinutes();
+      const secondTime = time.getMinutes();
+
+      expect(firstTime.valueOf()).toBe(59);
+      expect(secondTime.valueOf()).toBe(59);
+    });
+  });
+
+  describe('getSeconds', () => {
+    it('should return the seconds', () => {
+      const milliseconds = 45 * 1000;
+      const time = Duration.fromMilliseconds(milliseconds);
+      const seconds = time.getSeconds();
+      expect(seconds.valueOf()).toBe(45);
+    });
+    it('should return the seconds', () => {
+      const milliseconds = 70 * 1000;
+      const time = Duration.fromMilliseconds(milliseconds);
+      const minutes = time.getSeconds();
+      expect(minutes.valueOf()).toBe(10);
+    });
+    it('should keep the value after getting it', () => {
+      const milliseconds = 45 * 1000;
+      const time = Duration.fromMilliseconds(milliseconds);
+      const firstTime = time.getSeconds();
+      const secondTime = time.getSeconds();
+
+      expect(firstTime.valueOf()).toBe(45);
+      expect(secondTime.valueOf()).toBe(45);
+    });
+  });
+
+  describe('getMilliseconds', () => {
+    it('should return the milliseconds', () => {
+      const milliseconds = 1500;
+      const time = Duration.fromMilliseconds(milliseconds);
+      expect(time.getMilliseconds().valueOf()).toBe(500);
+    });
+    it('should keep the value after getting it', () => {
+      const milliseconds = 1500;
+      const time = Duration.fromMilliseconds(milliseconds);
+      const firstTime = time.getMilliseconds();
+      const secondTime = time.getMilliseconds();
+
+      expect(firstTime.valueOf()).toBe(500);
+      expect(secondTime.valueOf()).toBe(500);
+    });
+  });
+
+  describe('valueOf', () => {
+    it('should return the value in milliseconds', () => {
+      const milliseconds = 500;
+      const time = Duration.fromMilliseconds(milliseconds);
+      expect(time.valueOf()).toBe(milliseconds);
+    });
+  });
+});