@haskou/value-objects 1.1.0 → 1.1.2

package/tests/value-objects/hashes/MD5Hash.spec.ts

@@ -1,187 +0,0 @@
-import { createHash } from 'crypto';
-
-import {
-  InvalidHashError,
-  MD5Hash,
-  NullObject,
-  StringValueObject,
-} from '../../../src';
-
-function computeMD5(input: string | Buffer): string {
-  return createHash('md5').update(input).digest('hex');
-}
-
-describe('MD5Hash', () => {
-  describe('constructor', () => {
-    it('should return a NullValueObject when a Nullish is received', () => {
-      expect(() => new MD5Hash(undefined as unknown as string)).not.toThrow();
-      expect(
-        NullObject.isNullObject(new MD5Hash(undefined as unknown as string)),
-      ).toBeTrue();
-    });
-
-    const validMD5Hashes = [
-      '5d41402abc4b2a76b9719d911017c592', // MD5 of 'hello'
-      '098f6bcd4621d373cade4e832627b4f6', // MD5 of 'test'
-      '9e107d9d372bb6826bd81d3542a419d6', // MD5 of 'password'
-      'd41d8cd98f00b204e9800998ecf8427e', // MD5 of empty string
-      'a665a45920422f9d417e4867efdc4fb8', // MD5 of 'admin'
-    ];
-
-    it.each(validMD5Hashes)(
-      'should create an MD5Hash instance for valid MD5 hash strings',
-      (hash) => {
-        expect(() => new MD5Hash(hash)).not.toThrow();
-        expect(new MD5Hash(hash).toString()).toBe(hash);
-      },
-    );
-
-    const invalidMD5Hashes = [
-      'invalid-hash',
-      '1234567890123456789012345678901', // 31 chars
-      '123456789012345678901234567890123', // 33 chars
-      'gggggggggggggggggggggggggggggggg', // 32 chars but invalid hex
-      '12345678901234567890123456789012g', // 32 chars with non-hex
-      '',
-      'a'.repeat(31),
-      'a'.repeat(33),
-    ];
-
-    it.each(invalidMD5Hashes)(
-      'should throw InvalidHashError for invalid MD5 hash strings',
-      (hash) => {
-        expect(() => new MD5Hash(hash)).toThrow(InvalidHashError);
-      },
-    );
-
-    it('should accept another StringValueObject', () => {
-      const hashString = new StringValueObject(
-        '5d41402abc4b2a76b9719d911017c592',
-      );
-      const hash = new MD5Hash(hashString);
-      expect(hash.toString()).toBe('5d41402abc4b2a76b9719d911017c592');
-    });
-
-    it('should validate hash format when constructed from StringValueObject', () => {
-      const invalidHashString = new StringValueObject('invalid-hash');
-      expect(() => new MD5Hash(invalidHashString)).toThrow(InvalidHashError);
-    });
-  });
-
-  describe('static methods', () => {
-    describe('isValid', () => {
-      it('should return true for valid MD5 hashes', () => {
-        const validHash = '5d41402abc4b2a76b9719d911017c592';
-        expect(MD5Hash.isValid(validHash)).toBeTrue();
-        expect(MD5Hash.isValid(new StringValueObject(validHash))).toBeTrue();
-      });
-
-      it('should return false for invalid MD5 hashes', () => {
-        expect(MD5Hash.isValid('invalid')).toBeFalse();
-        expect(MD5Hash.isValid('123')).toBeFalse();
-        expect(MD5Hash.isValid('gggggggggggggggggggggggggggggggg')).toBeFalse();
-      });
-    });
-
-    describe('from', () => {
-      it('should compute MD5 hash from string', () => {
-        const input = 'hello';
-        const expected = computeMD5(input);
-        const hash = MD5Hash.from(input);
-        expect(hash.valueOf()).toBe(expected);
-      });
-
-      it('should compute MD5 hash from Buffer', () => {
-        const input = Buffer.from('hello');
-        const expected = computeMD5(input);
-        const hash = MD5Hash.from(input);
-        expect(hash.valueOf()).toBe(expected);
-      });
-
-      it('should compute MD5 hash from StringValueObject', () => {
-        const input = new StringValueObject('hello');
-        const expected = computeMD5(input.valueOf());
-        const hash = MD5Hash.from(input);
-        expect(hash.valueOf()).toBe(expected);
-      });
-    });
-  });
-
-  describe('inheritance and ValueObject behavior', () => {
-    it('should inherit from ValueObject', () => {
-      const hash = new MD5Hash('5d41402abc4b2a76b9719d911017c592');
-      expect(hash).toBeInstanceOf(MD5Hash);
-      expect(hash.valueOf).toBeDefined();
-      expect(hash.isEqual).toBeDefined();
-      expect(hash.toString).toBeDefined();
-    });
-
-    it('should implement valueOf() method correctly', () => {
-      const hashValue = '098f6bcd4621d373cade4e832627b4f6';
-      const hash = new MD5Hash(hashValue);
-      expect(hash.valueOf()).toBe(hashValue);
-    });
-
-    it('should implement toString() method correctly', () => {
-      const hashValue = '9e107d9d372bb6826bd81d3542a419d6';
-      const hash = new MD5Hash(hashValue);
-      expect(hash.toString()).toBe(hashValue);
-    });
-
-    it('should implement isEqual() method correctly', () => {
-      const hashValue = '5d41402abc4b2a76b9719d911017c592';
-      const hash1 = new MD5Hash(hashValue);
-      const hash2 = new MD5Hash(hashValue);
-      const hash3 = new MD5Hash('098f6bcd4621d373cade4e832627b4f6');
-
-      expect(hash1.isEqual(hash2)).toBeTrue();
-      expect(hash1.isEqual(hash3)).toBeFalse();
-      expect(hash1.isEqual(hashValue)).toBeTrue();
-      expect(hash1.isEqual('098f6bcd4621d373cade4e832627b4f6')).toBeFalse();
-    });
-
-    it('should compare with string values using isEqual', () => {
-      const hash = new MD5Hash('5d41402abc4b2a76b9719d911017c592');
-      expect(hash.isEqual('5d41402abc4b2a76b9719d911017c592')).toBeTrue();
-      expect(hash.isEqual('098f6bcd4621d373cade4e832627b4f6')).toBeFalse();
-    });
-
-    it('should implement clone() method correctly inherited from ValueObject', () => {
-      const originalValue = '5d41402abc4b2a76b9719d911017c592';
-      const original = new MD5Hash(originalValue);
-      const cloned = (original as any).clone();
-
-      expect(cloned).toBeInstanceOf(MD5Hash);
-      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 hash validation in cloned instances', () => {
-      const original = new MD5Hash('5d41402abc4b2a76b9719d911017c592');
-      const cloned = (original as any).clone();
-
-      expect(cloned).toBeInstanceOf(MD5Hash);
-      expect(cloned.valueOf()).toBe('5d41402abc4b2a76b9719d911017c592');
-
-      // Cloned instance should still be a valid hash
-      expect(() => cloned.toString()).not.toThrow();
-      expect(cloned.toString()).toBe('5d41402abc4b2a76b9719d911017c592');
-    });
-  });
-
-  describe('instance methods', () => {
-    describe('toBase64', () => {
-      it('should convert hash to base64 correctly', () => {
-        const hashValue = '5d41402abc4b2a76b9719d911017c592';
-        const hash = new MD5Hash(hashValue);
-        const base64 = hash.toBase64();
-        expect(base64).toBeInstanceOf(StringValueObject);
-        expect(base64.valueOf()).toBe(
-          Buffer.from(hashValue, 'hex').toString('base64'),
-        );
-      });
-    });
-  });
-});

package/tests/value-objects/hashes/SHA256Hash.spec.ts

@@ -1,220 +0,0 @@
-import { createHash } from 'crypto';
-import {
-  SHA256Hash,
-  NullObject,
-  InvalidHashError,
-  StringValueObject,
-} from '../../../src';
-
-function computeSHA256(input: string | Buffer): string {
-  return createHash('sha256').update(input).digest('hex');
-}
-
-describe('SHA256Hash', () => {
-  describe('constructor', () => {
-    it('should return a NullValueObject when a Nullish is received', () => {
-      expect(
-        () => new SHA256Hash(undefined as unknown as string),
-      ).not.toThrow();
-      expect(
-        NullObject.isNullObject(new SHA256Hash(undefined as unknown as string)),
-      ).toBeTrue();
-    });
-
-    const validSHA256Hashes = [
-      '2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824', // SHA256 of 'hello'
-      '9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08', // SHA256 of 'test'
-      '5e884898da28047151d0e56f8dc6292773603d0d6aabbdd62a11ef721d1542d8', // SHA256 of 'password'
-      'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', // SHA256 of empty string
-      '8c6976e5b5410415bde908bd4dee15dfb167a9c873fc4bb8a81f6f2ab448a918', // SHA256 of 'admin'
-    ];
-
-    it.each(validSHA256Hashes)(
-      'should create an SHA256Hash instance for valid SHA256 hash strings',
-      (hash) => {
-        expect(() => new SHA256Hash(hash)).not.toThrow();
-        expect(new SHA256Hash(hash).toString()).toBe(hash);
-      },
-    );
-
-    const invalidSHA256Hashes = [
-      'invalid-hash',
-      '2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b982', // 63 chars
-      '2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b98245', // 65 chars
-      'gggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg', // 64 chars but invalid hex
-      '2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b982g', // 64 chars with non-hex
-      '',
-      'a'.repeat(63),
-      'a'.repeat(65),
-    ];
-
-    it.each(invalidSHA256Hashes)(
-      'should throw InvalidHashError for invalid SHA256 hash strings',
-      (hash) => {
-        expect(() => new SHA256Hash(hash)).toThrow(InvalidHashError);
-      },
-    );
-
-    it('should accept another StringValueObject', () => {
-      const hashString = new StringValueObject(
-        '2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824',
-      );
-      const hash = new SHA256Hash(hashString);
-      expect(hash.toString()).toBe(
-        '2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824',
-      );
-    });
-
-    it('should validate hash format when constructed from StringValueObject', () => {
-      const invalidHashString = new StringValueObject('invalid-hash');
-      expect(() => new SHA256Hash(invalidHashString)).toThrow(InvalidHashError);
-    });
-  });
-
-  describe('static methods', () => {
-    describe('isValid', () => {
-      it('should return true for valid SHA256 hashes', () => {
-        const validHash =
-          '2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824';
-        expect(SHA256Hash.isValid(validHash)).toBeTrue();
-        expect(SHA256Hash.isValid(new StringValueObject(validHash))).toBeTrue();
-      });
-
-      it('should return false for invalid SHA256 hashes', () => {
-        expect(SHA256Hash.isValid('invalid')).toBeFalse();
-        expect(SHA256Hash.isValid('123')).toBeFalse();
-        expect(SHA256Hash.isValid('g'.repeat(64))).toBeFalse();
-      });
-    });
-
-    describe('from', () => {
-      it('should compute SHA256 hash from string', () => {
-        const input = 'hello';
-        const expected = computeSHA256(input);
-        const hash = SHA256Hash.from(input);
-        expect(hash.valueOf()).toBe(expected);
-      });
-
-      it('should compute SHA256 hash from Buffer', () => {
-        const input = Buffer.from('hello');
-        const expected = computeSHA256(input);
-        const hash = SHA256Hash.from(input);
-        expect(hash.valueOf()).toBe(expected);
-      });
-
-      it('should compute SHA256 hash from StringValueObject', () => {
-        const input = new StringValueObject('hello');
-        const expected = computeSHA256(input.valueOf());
-        const hash = SHA256Hash.from(input);
-        expect(hash.valueOf()).toBe(expected);
-      });
-    });
-  });
-
-  describe('inheritance and ValueObject behavior', () => {
-    it('should inherit from ValueObject', () => {
-      const hash = new SHA256Hash(
-        '2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824',
-      );
-      expect(hash).toBeInstanceOf(SHA256Hash);
-      expect(hash.valueOf).toBeDefined();
-      expect(hash.isEqual).toBeDefined();
-      expect(hash.toString).toBeDefined();
-    });
-
-    it('should implement valueOf() method correctly', () => {
-      const hashValue =
-        '9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08';
-      const hash = new SHA256Hash(hashValue);
-      expect(hash.valueOf()).toBe(hashValue);
-    });
-
-    it('should implement toString() method correctly', () => {
-      const hashValue =
-        '5e884898da28047151d0e56f8dc6292773603d0d6aabbdd62a11ef721d1542d8';
-      const hash = new SHA256Hash(hashValue);
-      expect(hash.toString()).toBe(hashValue);
-    });
-
-    it('should implement isEqual() method correctly', () => {
-      const hashValue =
-        '2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824';
-      const hash1 = new SHA256Hash(hashValue);
-      const hash2 = new SHA256Hash(hashValue);
-      const hash3 = new SHA256Hash(
-        '9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08',
-      );
-
-      expect(hash1.isEqual(hash2)).toBeTrue();
-      expect(hash1.isEqual(hash3)).toBeFalse();
-      expect(hash1.isEqual(hashValue)).toBeTrue();
-      expect(
-        hash1.isEqual(
-          '9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08',
-        ),
-      ).toBeFalse();
-    });
-
-    it('should compare with string values using isEqual', () => {
-      const hash = new SHA256Hash(
-        '2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824',
-      );
-      expect(
-        hash.isEqual(
-          '2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824',
-        ),
-      ).toBeTrue();
-      expect(
-        hash.isEqual(
-          '9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08',
-        ),
-      ).toBeFalse();
-    });
-
-    it('should implement clone() method correctly inherited from ValueObject', () => {
-      const originalValue =
-        '2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824';
-      const original = new SHA256Hash(originalValue);
-      const cloned = (original as any).clone();
-
-      expect(cloned).toBeInstanceOf(SHA256Hash);
-      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 hash validation in cloned instances', () => {
-      const original = new SHA256Hash(
-        '2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824',
-      );
-      const cloned = (original as any).clone();
-
-      expect(cloned).toBeInstanceOf(SHA256Hash);
-      expect(cloned.valueOf()).toBe(
-        '2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824',
-      );
-
-      // Cloned instance should still be a valid hash
-      expect(() => cloned.toString()).not.toThrow();
-      expect(cloned.toString()).toBe(
-        '2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824',
-      );
-    });
-  });
-
-  describe('instance methods', () => {
-    describe('toBase64', () => {
-      it('should convert hash to base64 correctly', () => {
-        const hashValue =
-          '2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824';
-        const hash = new SHA256Hash(hashValue);
-        const base64 = hash.toBase64();
-        expect(base64).toBeInstanceOf(StringValueObject);
-        expect(base64.valueOf()).toBe(
-          Buffer.from(hashValue, 'hex').toString('base64'),
-        );
-      });
-    });
-  });
-});

package/tests/value-objects/hashes/SHA512Hash.spec.ts

@@ -1,220 +0,0 @@
-import { createHash } from 'crypto';
-import {
-  SHA512Hash,
-  NullObject,
-  InvalidHashError,
-  StringValueObject,
-} from '../../../src';
-
-function computeSHA512(input: string | Buffer): string {
-  return createHash('sha512').update(input).digest('hex');
-}
-
-describe('SHA512Hash', () => {
-  describe('constructor', () => {
-    it('should return a NullValueObject when a Nullish is received', () => {
-      expect(
-        () => new SHA512Hash(undefined as unknown as string),
-      ).not.toThrow();
-      expect(
-        NullObject.isNullObject(new SHA512Hash(undefined as unknown as string)),
-      ).toBeTrue();
-    });
-
-    const validSHA512Hashes = [
-      '9b71d224bd62f3785d96d46ad3ea3d73319bfbc2890caadae2dff72519673ca72323c3d99ba5c11d7c7acc6e14b8c5da0c4663475c2e5c3adef46f73bcdec043', // SHA512 of 'hello'
-      'ee26b0dd4af7e749aa1a8ee3c10ae9923f618980772e473f8819a5d4940e0db27ac185f8a0e1d5f84f88bc887fd67b143732c304cc5fa9ad8e6f57f50028a8ff', // SHA512 of 'test'
-      'b109f3bbbc244eb82441917ed06d618b9008dd09b3befd1b5e07394c706a8bb980b1d7785e5976ec049b46df5f1326af5a2ea6d103fd07c95385ffab0cacbc86', // SHA512 of 'password'
-      'cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e', // SHA512 of empty string
-      'c7ad44cbad762a5da0a452f9e854fdc1e0e7a52a38015f23f3eab1d80b931dd472634dfac71cd34ebc35d16ab7fb8a90c81f975113d6c7538dc69dd8de9077ec', // SHA512 of 'admin'
-    ];
-
-    it.each(validSHA512Hashes)(
-      'should create an SHA512Hash instance for valid SHA512 hash strings',
-      (hash) => {
-        expect(() => new SHA512Hash(hash)).not.toThrow();
-        expect(new SHA512Hash(hash).toString()).toBe(hash);
-      },
-    );
-
-    const invalidSHA512Hashes = [
-      'invalid-hash',
-      '9b71d224bd62f3785d96d46ad3ea3d73319bfbc2890caadae2dff72519673ca7232', // 127 chars
-      '9b71d224bd62f3785d96d46ad3ea3d73319bfbc2890caadae2dff72519673ca723234', // 129 chars
-      'g'.repeat(128), // 128 chars but invalid hex
-      '9b71d224bd62f3785d96d46ad3ea3d73319bfbc2890caadae2dff72519673ca7232g', // 128 chars with non-hex
-      '',
-      'a'.repeat(127),
-      'a'.repeat(129),
-    ];
-
-    it.each(invalidSHA512Hashes)(
-      'should throw InvalidHashError for invalid SHA512 hash strings',
-      (hash) => {
-        expect(() => new SHA512Hash(hash)).toThrow(InvalidHashError);
-      },
-    );
-
-    it('should accept another StringValueObject', () => {
-      const hashString = new StringValueObject(
-        '9b71d224bd62f3785d96d46ad3ea3d73319bfbc2890caadae2dff72519673ca72323c3d99ba5c11d7c7acc6e14b8c5da0c4663475c2e5c3adef46f73bcdec043',
-      );
-      const hash = new SHA512Hash(hashString);
-      expect(hash.toString()).toBe(
-        '9b71d224bd62f3785d96d46ad3ea3d73319bfbc2890caadae2dff72519673ca72323c3d99ba5c11d7c7acc6e14b8c5da0c4663475c2e5c3adef46f73bcdec043',
-      );
-    });
-
-    it('should validate hash format when constructed from StringValueObject', () => {
-      const invalidHashString = new StringValueObject('invalid-hash');
-      expect(() => new SHA512Hash(invalidHashString)).toThrow(InvalidHashError);
-    });
-  });
-
-  describe('static methods', () => {
-    describe('isValid', () => {
-      it('should return true for valid SHA512 hashes', () => {
-        const validHash =
-          '9b71d224bd62f3785d96d46ad3ea3d73319bfbc2890caadae2dff72519673ca72323c3d99ba5c11d7c7acc6e14b8c5da0c4663475c2e5c3adef46f73bcdec043';
-        expect(SHA512Hash.isValid(validHash)).toBeTrue();
-        expect(SHA512Hash.isValid(new StringValueObject(validHash))).toBeTrue();
-      });
-
-      it('should return false for invalid SHA512 hashes', () => {
-        expect(SHA512Hash.isValid('invalid')).toBeFalse();
-        expect(SHA512Hash.isValid('123')).toBeFalse();
-        expect(SHA512Hash.isValid('g'.repeat(128))).toBeFalse();
-      });
-    });
-
-    describe('from', () => {
-      it('should compute SHA512 hash from string', () => {
-        const input = 'hello';
-        const expected = computeSHA512(input);
-        const hash = SHA512Hash.from(input);
-        expect(hash.valueOf()).toBe(expected);
-      });
-
-      it('should compute SHA512 hash from Buffer', () => {
-        const input = Buffer.from('hello');
-        const expected = computeSHA512(input);
-        const hash = SHA512Hash.from(input);
-        expect(hash.valueOf()).toBe(expected);
-      });
-
-      it('should compute SHA512 hash from StringValueObject', () => {
-        const input = new StringValueObject('hello');
-        const expected = computeSHA512(input.valueOf());
-        const hash = SHA512Hash.from(input);
-        expect(hash.valueOf()).toBe(expected);
-      });
-    });
-  });
-
-  describe('inheritance and ValueObject behavior', () => {
-    it('should inherit from ValueObject', () => {
-      const hash = new SHA512Hash(
-        '9b71d224bd62f3785d96d46ad3ea3d73319bfbc2890caadae2dff72519673ca72323c3d99ba5c11d7c7acc6e14b8c5da0c4663475c2e5c3adef46f73bcdec043',
-      );
-      expect(hash).toBeInstanceOf(SHA512Hash);
-      expect(hash.valueOf).toBeDefined();
-      expect(hash.isEqual).toBeDefined();
-      expect(hash.toString).toBeDefined();
-    });
-
-    it('should implement valueOf() method correctly', () => {
-      const hashValue =
-        'ee26b0dd4af7e749aa1a8ee3c10ae9923f618980772e473f8819a5d4940e0db27ac185f8a0e1d5f84f88bc887fd67b143732c304cc5fa9ad8e6f57f50028a8ff';
-      const hash = new SHA512Hash(hashValue);
-      expect(hash.valueOf()).toBe(hashValue);
-    });
-
-    it('should implement toString() method correctly', () => {
-      const hashValue =
-        'b109f3bbbc244eb82441917ed06d618b9008dd09b3befd1b5e07394c706a8bb980b1d7785e5976ec049b46df5f1326af5a2ea6d103fd07c95385ffab0cacbc86';
-      const hash = new SHA512Hash(hashValue);
-      expect(hash.toString()).toBe(hashValue);
-    });
-
-    it('should implement isEqual() method correctly', () => {
-      const hashValue =
-        '9b71d224bd62f3785d96d46ad3ea3d73319bfbc2890caadae2dff72519673ca72323c3d99ba5c11d7c7acc6e14b8c5da0c4663475c2e5c3adef46f73bcdec043';
-      const hash1 = new SHA512Hash(hashValue);
-      const hash2 = new SHA512Hash(hashValue);
-      const hash3 = new SHA512Hash(
-        'ee26b0dd4af7e749aa1a8ee3c10ae9923f618980772e473f8819a5d4940e0db27ac185f8a0e1d5f84f88bc887fd67b143732c304cc5fa9ad8e6f57f50028a8ff',
-      );
-
-      expect(hash1.isEqual(hash2)).toBeTrue();
-      expect(hash1.isEqual(hash3)).toBeFalse();
-      expect(hash1.isEqual(hashValue)).toBeTrue();
-      expect(
-        hash1.isEqual(
-          'ee26b0dd4af7e749aa1a8ee3c10ae9923f618980772e473f8819a5d4940e0db27ac185f8a0e1d5f84f88bc887fd67b143732c304cc5fa9ad8e6f57f50028a8ff',
-        ),
-      ).toBeFalse();
-    });
-
-    it('should compare with string values using isEqual', () => {
-      const hash = new SHA512Hash(
-        '9b71d224bd62f3785d96d46ad3ea3d73319bfbc2890caadae2dff72519673ca72323c3d99ba5c11d7c7acc6e14b8c5da0c4663475c2e5c3adef46f73bcdec043',
-      );
-      expect(
-        hash.isEqual(
-          '9b71d224bd62f3785d96d46ad3ea3d73319bfbc2890caadae2dff72519673ca72323c3d99ba5c11d7c7acc6e14b8c5da0c4663475c2e5c3adef46f73bcdec043',
-        ),
-      ).toBeTrue();
-      expect(
-        hash.isEqual(
-          'ee26b0dd4af7e749aa1a8ee3c10ae9923f618980772e473f8819a5d4940e0db27ac185f8a0e1d5f84f88bc887fd67b143732c304cc5fa9ad8e6f57f50028a8ff',
-        ),
-      ).toBeFalse();
-    });
-
-    it('should implement clone() method correctly inherited from ValueObject', () => {
-      const originalValue =
-        '9b71d224bd62f3785d96d46ad3ea3d73319bfbc2890caadae2dff72519673ca72323c3d99ba5c11d7c7acc6e14b8c5da0c4663475c2e5c3adef46f73bcdec043';
-      const original = new SHA512Hash(originalValue);
-      const cloned = (original as any).clone();
-
-      expect(cloned).toBeInstanceOf(SHA512Hash);
-      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 hash validation in cloned instances', () => {
-      const original = new SHA512Hash(
-        '9b71d224bd62f3785d96d46ad3ea3d73319bfbc2890caadae2dff72519673ca72323c3d99ba5c11d7c7acc6e14b8c5da0c4663475c2e5c3adef46f73bcdec043',
-      );
-      const cloned = (original as any).clone();
-
-      expect(cloned).toBeInstanceOf(SHA512Hash);
-      expect(cloned.valueOf()).toBe(
-        '9b71d224bd62f3785d96d46ad3ea3d73319bfbc2890caadae2dff72519673ca72323c3d99ba5c11d7c7acc6e14b8c5da0c4663475c2e5c3adef46f73bcdec043',
-      );
-
-      // Cloned instance should still be a valid hash
-      expect(() => cloned.toString()).not.toThrow();
-      expect(cloned.toString()).toBe(
-        '9b71d224bd62f3785d96d46ad3ea3d73319bfbc2890caadae2dff72519673ca72323c3d99ba5c11d7c7acc6e14b8c5da0c4663475c2e5c3adef46f73bcdec043',
-      );
-    });
-  });
-
-  describe('instance methods', () => {
-    describe('toBase64', () => {
-      it('should convert hash to base64 correctly', () => {
-        const hashValue =
-          '9b71d224bd62f3785d96d46ad3ea3d73319bfbc2890caadae2dff72519673ca72323c3d99ba5c11d7c7acc6e14b8c5da0c4663475c2e5c3adef46f73bcdec043';
-        const hash = new SHA512Hash(hashValue);
-        const base64 = hash.toBase64();
-        expect(base64).toBeInstanceOf(StringValueObject);
-        expect(base64.valueOf()).toBe(
-          Buffer.from(hashValue, 'hex').toString('base64'),
-        );
-      });
-    });
-  });
-});

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

@@ -1,34 +0,0 @@
-import { InvalidFormatError } from '../../../src/errors/InvalidFormatError';
-import { InvalidLengthError } from '../../../src/errors/InvalidLengthError';
-import { InvalidValueError } from '../../../src/errors/InvalidValueError';
-import { ShortId } from '../../../src/value-objects/ids/ShortId';
-
-describe('ShortId', () => {
-  describe('generate', () => {
-    it('should generate a valid ShortId', () => {
-      const id = ShortId.generate();
-      expect(id).toBeInstanceOf(ShortId);
-      expect(id.toString()).toHaveLength(24);
-    });
-  });
-  describe('constructor', () => {
-    it('should throw invalid length error when constructor receives a empty string', () => {
-      expect(() => new ShortId('')).toThrow(InvalidLengthError);
-    });
-
-    it('should throw invalid format when value is not a valid id', () => {
-      expect(() => new ShortId('123')).toThrow(InvalidLengthError);
-    });
-
-    it("should be a valid id when it's 24 length string", () => {
-      expect(() => new ShortId('12345678901234567890abcd')).not.toThrow();
-      expect(new ShortId('12345678901234567890abcd')).toBeInstanceOf(ShortId);
-    });
-
-    it("should be invalid id when it's 24 length but invalid characters", () => {
-      expect(() => new ShortId('123456789@123456789#abcd')).toThrow(
-        InvalidFormatError,
-      );
-    });
-  });
-});