@haskou/value-objects 1.1.0 → 1.1.2

package/tests/value-objects/ids/UUID.spec.ts

@@ -1,37 +0,0 @@
-import { InvalidFormatError } from '../../../src/errors/InvalidFormatError';
-import { InvalidLengthError } from '../../../src/errors/InvalidLengthError';
-import { UUID } from '../../../src/value-objects/ids/UUID';
-
-describe('UUID', () => {
-  describe('generate', () => {
-    it('should generate a valid LongId', () => {
-      const id = UUID.generate();
-      expect(id).toBeInstanceOf(UUID);
-      expect(id.toString()).toHaveLength(36);
-    });
-  });
-  describe('constructor', () => {
-    it('should throw invalid length error when constructor receives a empty string', () => {
-      expect(() => new UUID('')).toThrow(InvalidLengthError);
-    });
-
-    it('should throw invalid format when value is not a valid id', () => {
-      expect(() => new UUID('123')).toThrow(InvalidLengthError);
-    });
-
-    it("should be a valid id when it's 36 length string", () => {
-      expect(
-        () => new UUID('8ab0b0f7-7324-4637-bc6b-109326f081c0'),
-      ).not.toThrow();
-      expect(new UUID('8ab0b0f7-7324-4637-bc6b-109326f081c0')).toBeInstanceOf(
-        UUID,
-      );
-    });
-
-    it("should be invalid id when it's 36 length but invalid characters", () => {
-      expect(() => new UUID('8ab0b0f7-7324#5637-bc6b-109326f081c0')).toThrow(
-        InvalidFormatError,
-      );
-    });
-  });
-});

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

@@ -1,182 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,71 +0,0 @@
-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

@@ -1,278 +0,0 @@
-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);
-    });
-  });
-});