@haskou/value-objects 1.1.0 → 1.1.2

package/tests/value-objects/Color.spec.ts

@@ -1,214 +0,0 @@
-import {
-  Color,
-  InvalidColorError,
-  NullObject,
-  StringValueObject,
-} from '../../src';
-
-describe('Color', () => {
-  describe('constructor', () => {
-    it('should return a NullValueObject when a Nullish is received', () => {
-      expect(() => new Color(undefined as unknown as string)).not.toThrow();
-      expect(
-        NullObject.isNullObject(new Color(undefined as unknown as string)),
-      ).toBeTrue();
-      expect(
-        NullObject.isNullObject(new Color(null as unknown as string)),
-      ).toBeTrue();
-    });
-
-    const validColors = [
-      '#FF0000',
-      '#00FF00',
-      '#0000FF',
-      '#FFFFFF',
-      '#000000',
-      '#FFA500',
-      '#000',
-      '#FFF',
-    ];
-    it.each(validColors)(
-      'should create a Color instance for valid hex color codes',
-      (color) => {
-        expect(() => new Color(color)).not.toThrow();
-      },
-    );
-
-    const invalidColors = [
-      '#GGGGGG',
-      '123456',
-      '#12345',
-      '#1234567',
-      'red',
-      '123',
-      '#HHH',
-      '',
-    ];
-    it.each(invalidColors)(
-      'should create a Color instance for valid hex color codes',
-      (color) => {
-        expect(() => new Color(color)).toThrow(InvalidColorError);
-      },
-    );
-  });
-
-  describe('predefined static colors', () => {
-    it('should have correct values for predefined colors', () => {
-      expect(Color.RED).toMatchObject({ value: '#FF0000' });
-      expect(Color.GREEN).toMatchObject({ value: '#00FF00' });
-      expect(Color.BLUE).toMatchObject({ value: '#0000FF' });
-      expect(Color.BLACK).toMatchObject({ value: '#000000' });
-      expect(Color.WHITE).toMatchObject({ value: '#FFFFFF' });
-      expect(Color.YELLOW).toMatchObject({ value: '#FFFF00' });
-      expect(Color.CYAN).toMatchObject({ value: '#00FFFF' });
-      expect(Color.MAGENTA).toMatchObject({ value: '#FF00FF' });
-      expect(Color.ORANGE).toMatchObject({ value: '#FFA500' });
-      expect(Color.PURPLE).toMatchObject({ value: '#800080' });
-      expect(Color.PINK).toMatchObject({ value: '#FFC0CB' });
-      expect(Color.BROWN).toMatchObject({ value: '#A52A2A' });
-    });
-  });
-
-  describe('equality', () => {
-    it('should return true for two Color instances with the same value', () => {
-      const color1 = new Color('#FF0000');
-      const color2 = new Color('#FF0000');
-      expect(color1.isEqual(color2)).toBe(true);
-    });
-
-    it('should return false for two Color instances with different values', () => {
-      const color1 = new Color('#FF0000');
-      const color2 = new Color('#00FF00');
-      expect(color1.isEqual(color2)).toBe(false);
-    });
-
-    it('should return true for two Color instances with the same value regardless of case', () => {
-      const color1 = new Color('#FF0000');
-      const color2 = new Color('#ff0000');
-      expect(color1.isEqual(color2)).toBe(true);
-    });
-
-    it('should return false when comparing a Color instance with null', () => {
-      const color1 = new Color('#FF0000');
-      expect(color1.isEqual(null as unknown as Color)).toBe(false);
-    });
-
-    it('should return false when comparing a Color instance with undefined', () => {
-      const color1 = new Color('#FF0000');
-      expect(color1.isEqual(undefined as unknown as Color)).toBe(false);
-    });
-  });
-
-  describe('inherited methods from StringValueObject', () => {
-    it('should return the correct string value using toString()', () => {
-      const color = new Color('#ABCDEF');
-      expect(color.toString()).toBe('#ABCDEF');
-    });
-
-    it('should return the correct primitive value using valueOf()', () => {
-      const color = new Color('#123456');
-      expect(color.valueOf()).toBe('#123456');
-    });
-
-    it('should be instance of StringValueObject', () => {
-      const color = new Color('#FFFFFF');
-      expect(color instanceof StringValueObject).toBe(true);
-    });
-
-    it('should be instance of Color', () => {
-      const color = new Color('#000000');
-      expect(color instanceof Color).toBe(true);
-    });
-
-    it('should compare equality using inherited equals() method', () => {
-      const color1 = new Color('#ABCDEF');
-      const color2 = new Color('#ABCDEF');
-      expect(color1.isEqual(color2)).toBe(true);
-    });
-
-    it('should compare inequality using inherited equals() method', () => {
-      const color1 = new Color('#ABCDEF');
-      const color2 = new Color('#123456');
-      expect(color1.isEqual(color2)).toBe(false);
-    });
-  });
-
-  describe('inheritance and StringValueObject behavior', () => {
-    it('should implement valueOf() method correctly from StringValueObject', () => {
-      const value = '#ABCDEF';
-      const color = new Color(value);
-      expect(color.valueOf()).toBe(value);
-    });
-
-    it('should implement toString() method correctly from StringValueObject', () => {
-      const value = '#123456';
-      const color = new Color(value);
-      expect(color.toString()).toBe(value);
-    });
-
-    it('should implement isEmpty() method correctly from StringValueObject', () => {
-      // Color cannot be empty due to validation, but method should exist
-      const color = new Color('#FFF');
-      expect(color.isEmpty()).toBeFalse();
-      expect(typeof color.isEmpty).toBe('function');
-    });
-
-    it('should override isEqual() method with case-insensitive comparison', () => {
-      const color1 = new Color('#FF0000');
-      const color2 = new Color('#ff0000');
-      const color3 = new Color('#00FF00');
-
-      expect(color1.isEqual(color2)).toBeTrue();
-      expect(color1.isEqual(color3)).toBeFalse();
-    });
-
-    it('should accept StringValueObject in constructor', () => {
-      const stringValueObject = new StringValueObject('#FFFFFF');
-      const color = new Color(stringValueObject);
-      expect(color.toString()).toBe('#FFFFFF');
-      expect(color.valueOf()).toBe('#FFFFFF');
-    });
-
-    it('should validate color format when constructed from StringValueObject', () => {
-      const invalidStringValueObject = new StringValueObject('invalid-color');
-      expect(() => new Color(invalidStringValueObject)).toThrow(
-        InvalidColorError,
-      );
-    });
-
-    it('should implement clone() method correctly inherited from ValueObject', () => {
-      const originalValue = '#ABCDEF';
-      const original = new Color(originalValue);
-      const cloned = (original as any).clone();
-
-      expect(cloned).toBeInstanceOf(Color);
-      expect(cloned).toBeInstanceOf(StringValueObject);
-      expect(cloned.valueOf()).toBe(originalValue);
-      expect(cloned.toString()).toBe(originalValue);
-      expect(cloned.isEqual(original)).toBeTrue();
-      expect(cloned).not.toBe(original); // Different instances
-    });
-
-    it('should clone static predefined colors correctly', () => {
-      const originalRed = Color.RED;
-      const clonedRed = (originalRed as any).clone();
-
-      expect(clonedRed).toBeInstanceOf(Color);
-      expect(clonedRed.valueOf()).toBe('#FF0000');
-      expect(clonedRed.isEqual(originalRed)).toBeTrue();
-      expect(clonedRed).not.toBe(originalRed);
-    });
-
-    it('should maintain color validation in cloned instances', () => {
-      const original = new Color('#123ABC');
-      const cloned = (original as any).clone();
-
-      expect(cloned).toBeInstanceOf(Color);
-      expect(cloned.valueOf()).toBe('#123ABC');
-
-      // Cloned instance should still be a valid color
-      expect(() => cloned.toString()).not.toThrow();
-      expect(cloned.toString()).toBe('#123ABC');
-    });
-  });
-});

package/tests/value-objects/Email.spec.ts

@@ -1,141 +0,0 @@
-import { Email, InvalidEmailError, StringValueObject } from '../../src';
-import { NullObject } from '../../src/value-objects/NullObject';
-
-describe('Email', () => {
-  describe('constructor', () => {
-    it('should return a NullValueObject when a Nullish is received', () => {
-      expect(() => new Email(undefined as unknown as string)).not.toThrow();
-      expect(
-        NullObject.isNullObject(new Email(undefined as unknown as string)),
-      ).toBeTrue();
-    });
-
-    const validEmails = [
-      'user@example.com',
-      'test.email@domain.org',
-      'user+tag@example.co.uk',
-      'first.last@subdomain.example.com',
-      'user_name@example-domain.com',
-      'test123@example.io',
-      'admin@company.travel',
-      'contact@site.museum',
-      'info@domain.photography',
-    ];
-
-    it.each(validEmails)(
-      'should create an Email instance for valid email addresses',
-      (email) => {
-        expect(() => new Email(email)).not.toThrow();
-        expect(new Email(email).toString()).toBe(email);
-      },
-    );
-
-    const invalidEmails = [
-      'invalid-email',
-      '@domain.com',
-      'user@',
-      'user@domain',
-      'user.domain.com',
-      'user@domain.',
-      'user@.com',
-      'user@@domain.com',
-      'user@domain..com',
-      'user name@domain.com',
-      'user@domain.c',
-      'user@domain.toolongextension',
-      '',
-    ];
-
-    it.each(invalidEmails)(
-      'should throw InvalidEmailError for invalid email addresses',
-      (email) => {
-        expect(() => new Email(email)).toThrow(InvalidEmailError);
-      },
-    );
-
-    it('should accept another StringValueObject', () => {
-      const emailString = new StringValueObject('user@example.com');
-      const email = new Email(emailString);
-      expect(email.toString()).toBe('user@example.com');
-    });
-
-    it('should validate email format when constructed from StringValueObject', () => {
-      const invalidEmailString = new StringValueObject('invalid-email');
-      expect(() => new Email(invalidEmailString)).toThrow(InvalidEmailError);
-    });
-  });
-
-  describe('inheritance and StringValueObject behavior', () => {
-    it('should inherit from StringValueObject', () => {
-      const email = new Email('test@example.com');
-      expect(email).toBeInstanceOf(Email);
-      expect(email).toBeInstanceOf(StringValueObject);
-      expect(email.valueOf).toBeDefined();
-      expect(email.isEqual).toBeDefined();
-      expect(email.toString).toBeDefined();
-      expect(email.isEmpty).toBeDefined();
-    });
-
-    it('should implement valueOf() method correctly from StringValueObject', () => {
-      const emailValue = 'admin@company.org';
-      const email = new Email(emailValue);
-      expect(email.valueOf()).toBe(emailValue);
-    });
-
-    it('should implement toString() method correctly from StringValueObject', () => {
-      const emailValue = 'contact@website.net';
-      const email = new Email(emailValue);
-      expect(email.toString()).toBe(emailValue);
-    });
-
-    it('should implement isEmpty() method correctly from StringValueObject', () => {
-      // Email cannot be empty due to validation, but method should exist
-      const email = new Email('user@domain.com');
-      expect(email.isEmpty()).toBeFalse();
-      expect(typeof email.isEmpty).toBe('function');
-    });
-
-    it('should implement isEqual() method correctly', () => {
-      const emailValue = 'test@example.com';
-      const email1 = new Email(emailValue);
-      const email2 = new Email(emailValue);
-      const email3 = new Email('different@example.com');
-
-      expect(email1.isEqual(email2)).toBeTrue();
-      expect(email1.isEqual(email3)).toBeFalse();
-      expect(email1.isEqual(emailValue)).toBeTrue();
-      expect(email1.isEqual('different@example.com')).toBeFalse();
-    });
-
-    it('should compare with string values using isEqual', () => {
-      const email = new Email('hello@world.com');
-      expect(email.isEqual('hello@world.com')).toBeTrue();
-      expect(email.isEqual('goodbye@world.com')).toBeFalse();
-    });
-
-    it('should implement clone() method correctly inherited from ValueObject', () => {
-      const originalValue = 'clone@test.com';
-      const original = new Email(originalValue);
-      const cloned = (original as any).clone();
-
-      expect(cloned).toBeInstanceOf(Email);
-      expect(cloned).toBeInstanceOf(StringValueObject);
-      expect(cloned.valueOf()).toBe(originalValue);
-      expect(cloned.toString()).toBe(originalValue);
-      expect(cloned.isEqual(original)).toBeTrue();
-      expect(cloned).not.toBe(original); // Different instances
-    });
-
-    it('should maintain email validation in cloned instances', () => {
-      const original = new Email('valid@example.com');
-      const cloned = (original as any).clone();
-
-      expect(cloned).toBeInstanceOf(Email);
-      expect(cloned.valueOf()).toBe('valid@example.com');
-
-      // Cloned instance should still be a valid email
-      expect(() => cloned.toString()).not.toThrow();
-      expect(cloned.toString()).toBe('valid@example.com');
-    });
-  });
-});

package/tests/value-objects/Enum.spec.ts

@@ -1,293 +0,0 @@
-import { Enum, NullObject, ValueNotInEnumError } from '../../src';
-
-class StringEnum extends Enum {
-  public getValues() {
-    return ['A', 'B', 'C'];
-  }
-}
-
-class NumberEnum extends Enum {
-  public getValues() {
-    return [1, 2, 3];
-  }
-}
-
-class MixedEnum extends Enum {
-  public getValues() {
-    return ['1', 2];
-  }
-}
-
-enum StatusEnum {
-  ACTIVE = 'active',
-  INACTIVE = 'inactive',
-  PENDING = 'pending',
-}
-
-class Status extends Enum {
-  public getValues() {
-    return Object.values(StatusEnum);
-  }
-
-  // Static factory methods for convenience
-  static ACTIVE = () => new Status(StatusEnum.ACTIVE);
-  static INACTIVE = () => new Status(StatusEnum.INACTIVE);
-  static PENDING = () => new Status(StatusEnum.PENDING);
-}
-
-describe('Enum', () => {
-  describe('constructor', () => {
-    it('should return a Null when a Nullish is received', () => {
-      expect(
-        () => new StringEnum(undefined as unknown as string),
-      ).not.toThrow();
-      expect(
-        NullObject.isNullObject(new StringEnum(undefined as unknown as string)),
-      ).toBeTrue();
-      expect(
-        NullObject.isNullObject(new StringEnum(null as unknown as string)),
-      ).toBeTrue();
-    });
-
-    it('should accept valid string enum values', () => {
-      expect(() => new StringEnum('A')).not.toThrow();
-      expect(() => new StringEnum('B')).not.toThrow();
-      expect(() => new StringEnum('C')).not.toThrow();
-
-      const enumValue = new StringEnum('A');
-      expect(enumValue.valueOf()).toBe('A');
-      expect(enumValue.toString()).toBe('A');
-    });
-
-    it('should accept valid number enum values', () => {
-      expect(() => new NumberEnum(1)).not.toThrow();
-      expect(() => new NumberEnum(2)).not.toThrow();
-      expect(() => new NumberEnum(3)).not.toThrow();
-
-      const enumValue = new NumberEnum(2);
-      expect(enumValue.valueOf()).toBe(2);
-      expect(enumValue.toString()).toBe('2');
-    });
-
-    it('should accept valid mixed enum values', () => {
-      expect(() => new MixedEnum('1')).not.toThrow();
-      expect(() => new MixedEnum(2)).not.toThrow();
-
-      const stringValue = new MixedEnum('1');
-      const numberValue = new MixedEnum(2);
-      expect(stringValue.valueOf()).toBe('1');
-      expect(numberValue.valueOf()).toBe(2);
-    });
-
-    it('should reject invalid string enum values', () => {
-      expect(() => new StringEnum('D')).toThrow(ValueNotInEnumError);
-      expect(() => new StringEnum('X')).toThrow(ValueNotInEnumError);
-      expect(() => new StringEnum('')).toThrow(ValueNotInEnumError);
-    });
-
-    it('should reject invalid number enum values', () => {
-      expect(() => new NumberEnum(0)).toThrow(ValueNotInEnumError);
-      expect(() => new NumberEnum(4)).toThrow(ValueNotInEnumError);
-      expect(() => new NumberEnum(-1)).toThrow(ValueNotInEnumError);
-    });
-
-    it('should reject invalid mixed enum values', () => {
-      expect(() => new MixedEnum('2')).toThrow(ValueNotInEnumError);
-      expect(() => new MixedEnum(1)).toThrow(ValueNotInEnumError);
-      expect(() => new MixedEnum('invalid')).toThrow(ValueNotInEnumError);
-    });
-
-    it('should work with TypeScript enum values', () => {
-      expect(() => new Status(StatusEnum.ACTIVE)).not.toThrow();
-      expect(() => new Status('active')).not.toThrow();
-      expect(() => new Status('inactive')).not.toThrow();
-      expect(() => new Status('pending')).not.toThrow();
-
-      const status = new Status(StatusEnum.ACTIVE);
-      expect(status.valueOf()).toBe('active');
-    });
-
-    it('should reject invalid TypeScript enum values', () => {
-      expect(() => new Status('unknown')).toThrow(ValueNotInEnumError);
-      expect(() => new Status('ACTIVE')).toThrow(ValueNotInEnumError); // Case sensitive
-    });
-  });
-
-  describe('inheritance and  behavior', () => {
-    it('should inherit from ', () => {
-      const enumValue = new StringEnum('A');
-      expect(enumValue).toBeInstanceOf(StringEnum);
-      expect(enumValue).toBeInstanceOf(Enum);
-      expect(enumValue.valueOf).toBeDefined();
-      expect(enumValue.isEqual).toBeDefined();
-      expect(enumValue.toString).toBeDefined();
-    });
-
-    it('should implement valueOf() method correctly', () => {
-      const stringEnum = new StringEnum('B');
-      const numberEnum = new NumberEnum(2);
-
-      expect(stringEnum.valueOf()).toBe('B');
-      expect(numberEnum.valueOf()).toBe(2);
-    });
-
-    it('should implement toString() method correctly from ', () => {
-      const stringEnum = new StringEnum('C');
-      const numberEnum = new NumberEnum(3);
-
-      expect(stringEnum.toString()).toBe('C');
-      expect(numberEnum.toString()).toBe('3');
-    });
-
-    it('should implement isEqual() method correctly', () => {
-      const enum1 = new StringEnum('A');
-      const enum2 = new StringEnum('A');
-      const enum3 = new StringEnum('B');
-
-      expect(enum1.isEqual(enum2)).toBeTrue();
-      expect(enum1.isEqual(enum3)).toBeFalse();
-      expect(enum1.isEqual('A')).toBeTrue();
-      expect(enum1.isEqual('B')).toBeFalse();
-    });
-
-    it('should compare with primitive values using isEqual', () => {
-      const stringEnum = new StringEnum('A');
-      const numberEnum = new NumberEnum(1);
-
-      expect(stringEnum.isEqual('A')).toBeTrue();
-      expect(stringEnum.isEqual('B')).toBeFalse();
-      expect(numberEnum.isEqual(1)).toBeTrue();
-      expect(numberEnum.isEqual(2)).toBeFalse();
-    });
-
-    it('should implement clone() method correctly', () => {
-      const original = new StringEnum('B');
-      const cloned = (original as any).clone();
-
-      expect(cloned).toBeInstanceOf(StringEnum);
-      expect(cloned).toBeInstanceOf(Enum);
-      expect(cloned.valueOf()).toBe('B');
-      expect(cloned.toString()).toBe('B');
-      expect(cloned.isEqual(original)).toBeTrue();
-      expect(cloned).not.toBe(original); // Different instances
-    });
-
-    it('should maintain enum validation in cloned instances', () => {
-      const original = new NumberEnum(3);
-      const cloned = (original as any).clone();
-
-      expect(cloned).toBeInstanceOf(NumberEnum);
-      expect(cloned.valueOf()).toBe(3);
-
-      // Cloned instance should still be a valid enum value
-      expect(() => cloned.toString()).not.toThrow();
-      expect(cloned.toString()).toBe('3');
-    });
-  });
-
-  describe('immutability', () => {
-    it('should have immutable value property inherited from ', () => {
-      const enumValue = new StringEnum('A');
-
-      // Verify immutability through value consistency
-      expect(enumValue.valueOf()).toBe('A');
-      expect((enumValue as any).value).toBe('A');
-
-      const originalValue = enumValue.valueOf();
-      expect(originalValue).toBe('A');
-    });
-
-    it('should return the same value after creation', () => {
-      const originalValue = 'B';
-      const enumValue = new StringEnum(originalValue);
-
-      expect(enumValue.valueOf()).toBe(originalValue);
-      expect(enumValue.toString()).toBe(originalValue);
-
-      // Value should remain the same
-      expect(enumValue.valueOf()).toBe(originalValue);
-    });
-
-    it('should create new instances instead of modifying existing ones', () => {
-      const value1 = 'A';
-      const value2 = 'C';
-
-      const enum1 = new StringEnum(value1);
-      const enum2 = new StringEnum(value2);
-
-      expect(enum1.valueOf()).toBe(value1);
-      expect(enum2.valueOf()).toBe(value2);
-      expect(enum1.valueOf()).not.toBe(enum2.valueOf());
-    });
-
-    it('should maintain immutability when cloning', () => {
-      const original = new NumberEnum(2);
-      const cloned = (original as any).clone();
-
-      expect(original.valueOf()).toBe(2);
-      expect(cloned.valueOf()).toBe(2);
-      expect(original.isEqual(cloned)).toBeTrue();
-      expect(original).not.toBe(cloned);
-
-      // Both should remain immutable
-      expect(original.valueOf()).toBe(2);
-      expect(cloned.valueOf()).toBe(2);
-    });
-  });
-
-  describe('enum validation', () => {
-    it('should validate against the defined enum values', () => {
-      const stringEnum = new StringEnum('A');
-      expect(stringEnum.valueOf()).toBe('A');
-
-      // Should be one of ['A', 'B', 'C']
-      expect(['A', 'B', 'C']).toContain(stringEnum.valueOf());
-    });
-
-    it('should provide meaningful error messages for invalid values', () => {
-      expect(() => new StringEnum('D')).toThrow(
-        /enum does not include value: D/,
-      );
-      expect(() => new NumberEnum(4)).toThrow(/enum does not include value: 4/);
-    });
-
-    it('should be case-sensitive for string enums', () => {
-      expect(() => new StringEnum('a')).toThrow(ValueNotInEnumError);
-      expect(() => new Status('ACTIVE')).toThrow(ValueNotInEnumError);
-    });
-
-    it('should handle type-sensitive validation for mixed enums', () => {
-      // '1' (string) is valid, but 1 (number) is not
-      expect(() => new MixedEnum('1')).not.toThrow();
-      expect(() => new MixedEnum(1)).toThrow(ValueNotInEnumError);
-
-      // 2 (number) is valid, but '2' (string) is not
-      expect(() => new MixedEnum(2)).not.toThrow();
-      expect(() => new MixedEnum('2')).toThrow(ValueNotInEnumError);
-    });
-  });
-
-  describe('static factory methods', () => {
-    it('should work with static factory methods for convenience', () => {
-      const activeStatus = Status.ACTIVE();
-      const inactiveStatus = Status.INACTIVE();
-      const pendingStatus = Status.PENDING();
-
-      expect(activeStatus.valueOf()).toBe('active');
-      expect(inactiveStatus.valueOf()).toBe('inactive');
-      expect(pendingStatus.valueOf()).toBe('pending');
-
-      expect(activeStatus).toBeInstanceOf(Status);
-      expect(inactiveStatus).toBeInstanceOf(Status);
-      expect(pendingStatus).toBeInstanceOf(Status);
-    });
-
-    it('should maintain equality with factory methods', () => {
-      const status1 = Status.ACTIVE();
-      const status2 = new Status('active');
-
-      expect(status1.isEqual(status2)).toBeTrue();
-      expect(status1.valueOf()).toBe(status2.valueOf());
-    });
-  });
-});

package/tests/value-objects/Integer.spec.ts

@@ -1,38 +0,0 @@
-import { Integer, InvalidIntegerError, InvalidNumberError } from '../../src';
-
-describe('Integer', () => {
-  it('should create an Integer for a valid integer', () => {
-    const value = 42;
-    const integer = new Integer(value);
-
-    expect(integer).toMatchObject({ value });
-  });
-
-  it('should throw InvalidIntegerError for a non-integer value', () => {
-    const value = 42.5;
-
-    expect(() => new Integer(value)).toThrow(InvalidIntegerError);
-    expect(() => new Integer(value)).toThrow(`Invalid integer value ${value}`);
-  });
-
-  it('should throw InvalidNumberError for NaN', () => {
-    const value = NaN;
-
-    expect(() => new Integer(value)).toThrow(InvalidNumberError);
-    expect(() => new Integer(value)).toThrow(`Invalid number ${value}`);
-  });
-
-  it('should throw InvalidIntegerError for Infinity', () => {
-    const value = Infinity;
-
-    expect(() => new Integer(value)).toThrow(InvalidIntegerError);
-    expect(() => new Integer(value)).toThrow(`Invalid integer value ${value}`);
-  });
-
-  it('should throw InvalidIntegerError for -Infinity', () => {
-    const value = -Infinity;
-
-    expect(() => new Integer(value)).toThrow(InvalidIntegerError);
-    expect(() => new Integer(value)).toThrow(`Invalid integer value ${value}`);
-  });
-});