@haskou/value-objects 1.0.3 → 1.1.0

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

@@ -0,0 +1,139 @@
+import { createHash } from 'crypto';
+import {
+  MD5Hash,
+  StringValueObject,
+  SHA256Hash,
+  SHA512Hash,
+} from '../../../src';
+import { InvalidHashError } from '../../../src/errors/InvalidHashError';
+
+function compute(hashName: string, input: string | Buffer): string {
+  return createHash(hashName).update(input).digest('hex');
+}
+
+describe('MD5Hash', () => {
+  const sample = 'hello';
+  const expected = compute('md5', sample);
+
+  describe('isValid', () => {
+    it('returns true for a valid 32-character hex string', () => {
+      expect(MD5Hash.isValid(expected)).toBeTrue();
+      expect(MD5Hash.isValid(new StringValueObject(expected))).toBeTrue();
+    });
+
+    it('returns false for malformed values', () => {
+      expect(MD5Hash.isValid('not-a-hash')).toBeFalse();
+      expect(MD5Hash.isValid(expected.slice(0, 10))).toBeFalse();
+    });
+  });
+
+  describe('from()', () => {
+    it('computes the correct hash from a string', () => {
+      const hash = MD5Hash.from(sample);
+      expect(hash.valueOf()).toBe(expected);
+    });
+
+    it('computes the correct hash from a buffer', () => {
+      const buf = Buffer.from(sample);
+      const hash = MD5Hash.from(buf);
+      expect(hash.valueOf()).toBe(expected);
+    });
+
+    it('accepts a StringValueObject as input', () => {
+      const hash = MD5Hash.from(new StringValueObject(sample));
+      expect(hash.valueOf()).toBe(expected);
+    });
+  });
+
+  describe('constructor', () => {
+    it('creates instance for valid hash', () => {
+      expect(() => new MD5Hash(expected)).not.toThrow();
+      expect(new MD5Hash(expected)).toBeInstanceOf(MD5Hash);
+    });
+
+    it('throws InvalidHashError for invalid values', () => {
+      expect(() => new MD5Hash('123')).toThrow(InvalidHashError);
+      expect(() => new MD5Hash('g'.repeat(32))).toThrow(InvalidHashError);
+    });
+
+    it('returns a NullObject when constructed with nullish', () => {
+      expect(() => new MD5Hash(undefined as unknown as string)).not.toThrow();
+    });
+  });
+
+  describe('toBase64', () => {
+    it('produces the expected base64 string', () => {
+      const hash = new MD5Hash(expected);
+      const base64 = hash.toBase64().valueOf();
+      expect(base64).toBe(Buffer.from(expected, 'hex').toString('base64'));
+    });
+  });
+});
+
+// SHA256 and SHA512 share similar behavior
+function hashTests(
+  Name: typeof SHA256Hash | typeof SHA512Hash,
+  algo: string,
+  length: number,
+) {
+  describe(Name.name, () => {
+    const sample = 'hello';
+    const expected = compute(algo, sample);
+
+    describe('isValid', () => {
+      it('returns true for valid string', () => {
+        expect(Name.isValid(expected)).toBeTrue();
+        expect(Name.isValid(new StringValueObject(expected))).toBeTrue();
+      });
+
+      it('returns false for invalid string', () => {
+        expect(Name.isValid('short')).toBeFalse();
+        expect(Name.isValid('g'.repeat(length))).toBeFalse();
+      });
+    });
+
+    describe('from()', () => {
+      it('computes the correct hash from a string', () => {
+        expect(Name.from(sample).valueOf()).toBe(expected);
+      });
+
+      it('computes the correct hash from a buffer', () => {
+        expect(Name.from(Buffer.from(sample)).valueOf()).toBe(expected);
+      });
+
+      it('accepts a StringValueObject as input', () => {
+        expect(Name.from(new StringValueObject(sample)).valueOf()).toBe(
+          expected,
+        );
+      });
+    });
+
+    describe('constructor', () => {
+      it('creates instance for valid hash', () => {
+        expect(() => new Name(expected)).not.toThrow();
+        expect(new Name(expected)).toBeInstanceOf(Name);
+      });
+
+      it('throws InvalidHashError for invalid values', () => {
+        expect(() => new Name('123')).toThrow(InvalidHashError);
+        expect(() => new Name('g'.repeat(length))).toThrow(InvalidHashError);
+      });
+
+      it('handles nullish input gracefully', () => {
+        expect(() => new Name(undefined as unknown as string)).not.toThrow();
+      });
+    });
+
+    describe('toBase64', () => {
+      it('produces the expected base64', () => {
+        const instance = new Name(expected);
+        expect(instance.toBase64().valueOf()).toBe(
+          Buffer.from(expected, 'hex').toString('base64'),
+        );
+      });
+    });
+  });
+}
+
+hashTests(SHA256Hash, 'sha256', 64);
+hashTests(SHA512Hash, 'sha512', 128);

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

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

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