pure-md5 0.2.0 → 0.2.2

package/__tests__/index.test.ts

@@ -1,87 +0,0 @@
-import { md5 } from '../src/index';
-
-describe('md5', () => {
-  // Test vectors from RFC 1321
-  test('should compute correct MD5 hash for RFC 1321 test vectors', () => {
-    // Test 1: empty string
-    expect(md5('')).toBe('d41d8cd98f00b204e9800998ecf8427e');
-
-    // Test 2: "a"
-    expect(md5('a')).toBe('0cc175b9c0f1b6a831c399e269772661');
-
-    // Test 3: "abc"
-    expect(md5('abc')).toBe('900150983cd24fb0d6963f7d28e17f72');
-
-    // Test 4: "message digest"
-    expect(md5('message digest')).toBe('f96b697d7cb7938d525a2f31aaf161d0');
-
-    // Test 5: "abcdefghijklmnopqrstuvwxyz"
-    expect(md5('abcdefghijklmnopqrstuvwxyz')).toBe(
-      'c3fcd3d76192e4007dfb496cca67e13b'
-    );
-
-    // Test 6: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
-    expect(
-      md5('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789')
-    ).toBe('d174ab98d277d9f5a5611c2c9f419d9f');
-
-    // Test 7: "12345678901234567890123456789012345678901234567890123456789012345678901234567890"
-    expect(
-      md5(
-        '12345678901234567890123456789012345678901234567890123456789012345678901234567890'
-      )
-    ).toBe('57edf4a22be3c955ac49da2e2107b67a');
-  });
-
-  test('should compute correct MD5 hash for common strings', () => {
-    // Test from the code itself
-    expect(md5('hello')).toBe('5d41402abc4b2a76b9719d911017c592');
-
-    // Additional common test cases
-    expect(md5('Hello, World!')).toBe('65a8e27d8879283831b664bd8b7f0ad4');
-    expect(md5('The quick brown fox jumps over the lazy dog')).toBe(
-      '9e107d9d372bb6826bd81d3542a419d6'
-    );
-    expect(md5('The quick brown fox jumps over the lazy dog.')).toBe(
-      'e4d909c290d0fb1ca068ffaddf22cbd0'
-    );
-  });
-
-  test('should handle edge cases', () => {
-    // Very long string
-    const longString = 'x'.repeat(10000);
-    const hash = md5(longString);
-    expect(hash).toMatch(/^[0-9a-f]{32}$/);
-
-    // Single character
-    expect(md5('x')).toBe('9dd4e461268c8034f5c8564e155c67a6');
-
-    // String with null bytes
-    expect(md5('test\0null')).toBe('530923740caad7aad6a2cd4b894d983d');
-  });
-
-  test('should produce consistent results', () => {
-    const input = 'test string';
-    const hash1 = md5(input);
-    const hash2 = md5(input);
-    const hash3 = md5(input);
-
-    expect(hash1).toBe(hash2);
-    expect(hash2).toBe(hash3);
-    expect(hash1).toMatch(/^[0-9a-f]{32}$/);
-  });
-
-  test('should handle Unicode strings (using UTF-16 code units)', () => {
-    // Note: This implementation uses charCodeAt() which returns UTF-16 code units
-    // This is different from UTF-8 encoding used by some other MD5 implementations
-    expect(md5('🎉')).toBe('801c2a6dbe01c0c530a03a5f5f5b1214');
-    expect(md5('Привет мир')).toBe('5abca3326cf0cefc00efe7065b5e0cf6'); // "Hello world" in Russian
-  });
-
-  test('should verify the built-in check works', () => {
-    // The function has a built-in check for 'hello'
-    // This ensures the runtime check doesn't break functionality
-    const result = md5('hello');
-    expect(result).toBe('5d41402abc4b2a76b9719d911017c592');
-  });
-});

package/__tests__/integration/fixtures/test-file.txt

@@ -1 +0,0 @@
-Hello, World!

package/__tests__/integration/md5-stream-file.test.ts

@@ -1,293 +0,0 @@
-/**
- * Integration tests for MD5Stream with real file I/O
- */
-
-import fs from 'fs';
-import path from 'path';
-import { MD5Stream, hashFile, hashFileSync, verifyFile, hashFileDigest } from '../../src/stream/index.js';
-import { md5Core } from '../../src/core/index.js';
-
-describe('MD5Stream - File I/O Integration', () => {
-  let tempDir: string;
-  
-  beforeAll(() => {
-    tempDir = path.join(__dirname, 'temp');
-    if (!fs.existsSync(tempDir)) {
-      fs.mkdirSync(tempDir, { recursive: true });
-    }
-  });
-  
-  afterAll(() => {
-    // Cleanup temp files
-    if (fs.existsSync(tempDir)) {
-      const files = fs.readdirSync(tempDir);
-      files.forEach(file => {
-        const filePath = path.join(tempDir, file);
-        if (fs.existsSync(filePath)) {
-          fs.unlinkSync(filePath);
-        }
-      });
-      fs.rmdirSync(tempDir);
-    }
-  });
-  
-  describe('hashFile (async)', () => {
-    test('should hash a small text file', async () => {
-      const filePath = path.join(tempDir, 'test-small.txt');
-      const content = 'Hello, World!';
-      fs.writeFileSync(filePath, content);
-      
-      const result = await hashFile(filePath);
-      
-      expect(result.digest).toBe(md5Core(content));
-      expect(result.bytesProcessed).toBe(content.length);
-      expect(result.digest.length).toBe(32);
-    });
-    
-    test('should hash an empty file', async () => {
-      const filePath = path.join(tempDir, 'test-empty.txt');
-      fs.writeFileSync(filePath, '');
-      
-      const result = await hashFile(filePath);
-      
-      expect(result.digest).toBe(md5Core(''));
-      expect(result.bytesProcessed).toBe(0);
-    });
-    
-    test('should handle file path as string', async () => {
-      const filePath = path.join(tempDir, 'test-path.txt');
-      const content = 'Path test content';
-      fs.writeFileSync(filePath, content);
-      
-      const result = await hashFile(filePath);
-      
-      expect(result.digest).toBe(md5Core(content));
-    });
-    
-    test('should handle large files efficiently', async () => {
-      const filePath = path.join(tempDir, 'test-large.bin');
-      const size = 10 * 1024 * 1024; // 10MB
-      const content = 'a'.repeat(size);
-      fs.writeFileSync(filePath, content);
-      
-      const start = Date.now();
-      const result = await hashFile(filePath);
-      const duration = Date.now() - start;
-      
-      expect(result.bytesProcessed).toBe(size);
-      expect(result.digest.length).toBe(32);
-      expect(duration).toBeLessThan(5000); // Should complete in under 5 seconds
-    }, 10000);
-  });
-  
-  describe('hashFileSync (sync)', () => {
-    test('should hash a small file synchronously', () => {
-      const filePath = path.join(tempDir, 'test-sync.txt');
-      const content = 'Sync hash test';
-      fs.writeFileSync(filePath, content);
-      
-      const digest = hashFileSync(filePath);
-      
-      expect(digest).toBe(md5Core(content));
-      expect(digest.length).toBe(32);
-    });
-    
-    test('should hash empty file synchronously', () => {
-      const filePath = path.join(tempDir, 'test-sync-empty.txt');
-      fs.writeFileSync(filePath, '');
-      
-      const digest = hashFileSync(filePath);
-      
-      expect(digest).toBe(md5Core(''));
-    });
-    
-    test('should be faster than async for small files', () => {
-      const filePath = path.join(tempDir, 'test-sync-performance.txt');
-      const content = 'a'.repeat(1000);
-      fs.writeFileSync(filePath, content);
-      
-      const startSync = Date.now();
-      hashFileSync(filePath);
-      const syncDuration = Date.now() - startSync;
-      
-      expect(syncDuration).toBeLessThan(100); // Sync should be fast for small files
-    });
-  });
-  
-  describe('hashFileDigest', () => {
-    test('should return only digest string', async () => {
-      const filePath = path.join(tempDir, 'test-digest.txt');
-      const content = 'Digest only test';
-      fs.writeFileSync(filePath, content);
-      
-      const digest = await hashFileDigest(filePath);
-      
-      expect(typeof digest).toBe('string');
-      expect(digest).toBe(md5Core(content));
-      expect(digest.length).toBe(32);
-    });
-  });
-  
-  describe('verifyFile', () => {
-    test('should verify correct hash', async () => {
-      const filePath = path.join(tempDir, 'test-verify.txt');
-      const content = 'Verification test';
-      const correctDigest = md5Core(content);
-      fs.writeFileSync(filePath, content);
-      
-      const isVerified = await verifyFile(filePath, correctDigest);
-      
-      expect(isVerified).toBe(true);
-    });
-    
-    test('should reject incorrect hash', async () => {
-      const filePath = path.join(tempDir, 'test-verify-wrong.txt');
-      const content = 'Verification test wrong';
-      const wrongDigest = '00000000000000000000000000000000';
-      fs.writeFileSync(filePath, content);
-      
-      const isVerified = await verifyFile(filePath, wrongDigest);
-      
-      expect(isVerified).toBe(false);
-    });
-    
-    test('should handle file not found', async () => {
-      const filePath = path.join(tempDir, 'test-verify-not-found.txt');
-      const digest = '00000000000000000000000000000000';
-      
-      await expect(verifyFile(filePath, digest)).rejects.toThrow();
-    });
-  });
-  
-  describe('MD5Stream with file streams', () => {
-    test('should hash file using fs.createReadStream', (done) => {
-      const filePath = path.join(tempDir, 'test-stream.txt');
-      const content = 'Stream file test';
-      fs.writeFileSync(filePath, content);
-      
-      const stream = new MD5Stream();
-      
-      stream.on('md5', (result) => {
-        expect(result.digest).toBe(md5Core(content));
-        expect(result.bytesProcessed).toBe(content.length);
-        done();
-      });
-      
-      fs.createReadStream(filePath).pipe(stream);
-    });
-    
-    test('should handle file stream errors gracefully', (done) => {
-      const stream = new MD5Stream();
-      
-      const source = fs.createReadStream('/nonexistent/file.txt');
-      
-      // Source stream will emit error, but it should not hang
-      source.on('error', (error) => {
-        // Error is on source stream, not MD5Stream
-        // This is expected behavior - the source stream emits the error
-        expect(error).toBeDefined();
-        done();
-      });
-      
-      // MD5Stream will just see end-of-stream since source fails early
-      stream.on('md5', () => {
-        // This shouldn't happen for non-existent file
-        done();
-      });
-      
-      source.pipe(stream);
-    });
-  });
-  
-  describe('Progress tracking', () => {
-    test('should support progress callback', (done) => {
-      const filePath = path.join(tempDir, 'test-progress.txt');
-      const content = 'a'.repeat(10000);
-      fs.writeFileSync(filePath, content);
-      
-      // Note: Current implementation doesn't have built-in progress
-      // This is a placeholder for future implementation
-      // For now, we just verify the file can be hashed
-      hashFile(filePath).then((result) => {
-        expect(result.bytesProcessed).toBe(content.length);
-        done();
-      });
-    });
-  });
-  
-  describe('Edge Cases', () => {
-    test('should handle special characters in filename', async () => {
-      const specialFileName = 'test with spaces & special!@#.txt';
-      const filePath = path.join(tempDir, specialFileName);
-      const content = 'Special filename test';
-      fs.writeFileSync(filePath, content);
-      
-      const result = await hashFile(filePath);
-      
-      expect(result.digest).toBe(md5Core(content));
-      
-      // Cleanup
-      if (fs.existsSync(filePath)) {
-        fs.unlinkSync(filePath);
-      }
-    });
-    
-    test('should handle binary file content', async () => {
-      const filePath = path.join(tempDir, 'test-binary.bin');
-      const content = Buffer.alloc(100);
-      for (let i = 0; i < 100; i++) {
-        content[i] = i % 256;
-      }
-      fs.writeFileSync(filePath, content);
-      
-      const result = await hashFile(filePath);
-      
-      expect(result.digest.length).toBe(32);
-      expect(result.bytesProcessed).toBe(100);
-    });
-    
-    test('should handle unicode filename', async () => {
-      const specialFileName = 'тест unicode 文件.txt';
-      const filePath = path.join(tempDir, specialFileName);
-      const content = 'Unicode filename test';
-      fs.writeFileSync(filePath, content);
-      
-      const result = await hashFile(filePath);
-      
-      expect(result.digest).toBe(md5Core(content));
-      
-      // Cleanup
-      if (fs.existsSync(filePath)) {
-        fs.unlinkSync(filePath);
-      }
-    });
-  });
-  
-  describe('Consistency', () => {
-    test('should produce same hash for same file', async () => {
-      const filePath = path.join(tempDir, 'test-consistency.txt');
-      const content = 'Consistency test';
-      fs.writeFileSync(filePath, content);
-      
-      const result1 = await hashFile(filePath);
-      const result2 = await hashFile(filePath);
-      const result3 = await hashFile(filePath);
-      
-      expect(result1.digest).toBe(result2.digest);
-      expect(result2.digest).toBe(result3.digest);
-    });
-    
-    test('should produce different hashes for different files', async () => {
-      const file1Path = path.join(tempDir, 'test-diff1.txt');
-      const file2Path = path.join(tempDir, 'test-diff2.txt');
-      
-      fs.writeFileSync(file1Path, 'Content 1');
-      fs.writeFileSync(file2Path, 'Content 2');
-      
-      const result1 = await hashFile(file1Path);
-      const result2 = await hashFile(file2Path);
-      
-      expect(result1.digest).not.toBe(result2.digest);
-    });
-  });
-});

package/__tests__/integration/node-crypto-file.test.ts

@@ -1,86 +0,0 @@
-/**
- * Integration tests for Node.js Crypto Backend with files
- */
-
-import fs from 'fs';
-import path from 'path';
-import { NodeCryptoBackend } from '../../src/adapters/node.js';
-
-describe('NodeCryptoBackend with Files', () => {
-  let backend: NodeCryptoBackend;
-  
-  beforeAll(() => {
-    if (!NodeCryptoBackend.isAvailable()) {
-      console.log('Node.js Crypto not available, skipping tests');
-      pending('Node.js Crypto not available');
-      return;
-    }
-    backend = new NodeCryptoBackend();
-  });
-  
-  it('should hash a file', async () => {
-    if (!backend) {
-      pending('Node.js Crypto not available');
-      return;
-    }
-    
-    const filePath = path.join(__dirname, 'fixtures', 'test-file.txt');
-    
-    if (!fs.existsSync(filePath)) {
-      console.log('Test file not found, creating it');
-      const fixturesDir = path.dirname(filePath);
-      if (!fs.existsSync(fixturesDir)) {
-        fs.mkdirSync(fixturesDir, { recursive: true });
-      }
-      fs.writeFileSync(filePath, 'Hello, World!');
-    }
-    
-    const content = fs.readFileSync(filePath);
-    const result = await backend.hashBinary(content);
-    expect(result.length).toBe(32);
-  });
-  
-  it('should handle large files efficiently', async () => {
-    if (!backend) {
-      pending('Node.js Crypto not available');
-      return;
-    }
-    
-    const filePath = path.join(__dirname, 'fixtures', 'large-file.bin');
-    
-    if (!fs.existsSync(filePath)) {
-      console.log('Large file not found, skipping');
-      return;
-    }
-    
-    const content = fs.readFileSync(filePath);
-    const start = Date.now();
-    const result = await backend.hashBinary(content);
-    const duration = Date.now() - start;
-    
-    expect(result.length).toBe(32);
-    expect(duration).toBeLessThan(500);
-  });
-  
-  it('should produce consistent hash for the same file', async () => {
-    if (!backend) {
-      pending('Node.js Crypto not available');
-      return;
-    }
-    
-    const filePath = path.join(__dirname, 'fixtures', 'test-file.txt');
-    
-    if (!fs.existsSync(filePath)) {
-      const fixturesDir = path.dirname(filePath);
-      if (!fs.existsSync(fixturesDir)) {
-        fs.mkdirSync(fixturesDir, { recursive: true });
-      }
-      fs.writeFileSync(filePath, 'Consistent Test Data');
-    }
-    
-    const content = fs.readFileSync(filePath);
-    const result1 = await backend.hashBinary(content);
-    const result2 = await backend.hashBinary(content);
-    expect(result1).toBe(result2);
-  });
-});

package/__tests__/integration/web-crypto.test.ts

@@ -1,38 +0,0 @@
-/**
- * Integration tests for Web Crypto Backend
- */
-
-import { md5, md5Adapter, getAllAvailableBackends } from '../../src/index';
-
-describe('WebCrypto Backend Integration', () => {
-  describe('md5 function', () => {
-    it('should use default backend correctly', async () => {
-      const result = await md5('hello');
-      expect(result).toBe('5d41402abc4b2a76b9719d911017c592');
-    });
-    
-    it('should handle empty string', async () => {
-      const result = await md5('');
-      expect(result).toBe('d41d8cd98f00b204e9800998ecf8427e');
-    });
-    
-    it('should handle unicode', async () => {
-      const result = await md5('Привет мир');
-      expect(result).toBe('5abca3326cf0cefc00efe7065b5e0cf6');
-    });
-  });
-  
-  describe('Backend availability', () => {
-    it('should detect available backends', async () => {
-      const available = await getAllAvailableBackends();
-      expect(Array.isArray(available)).toBe(true);
-      expect(available.length).toBeGreaterThan(0);
-    });
-    
-    it('should use md5Adapter with webcrypto', async () => {
-      // Check if WebCrypto is available
-      const webcryptoAvailable = (md5Adapter as any).createBackendByName('webcrypto');
-      expect(webcryptoAvailable).toBeDefined();
-    });
-  });
-});

package/__tests__/md51.test.ts

@@ -1,73 +0,0 @@
-import md51 from '../src/md51';
-
-describe('md51', () => {
-  test('should compute MD5 hash for empty string', () => {
-    const result = md51('');
-
-    // MD5 of empty string: d41d8cd98f00b204e9800998ecf8427e
-    // In little-endian words: [0xd98cd41d, 0x04b2008f, 0x980099e9, 0x7e42f8ec]
-    // But let's just verify it produces 4 numbers
-    expect(result).toHaveLength(4);
-    result.forEach((val) => {
-      expect(Number.isInteger(val)).toBe(true);
-    });
-  });
-
-  test('should compute MD5 hash for "hello"', () => {
-    const result = md51('hello');
-
-    // MD5 of "hello": 5d41402abc4b2a76b9719d911017c592
-    // In little-endian words: [0x2a40415d, 0x762a4bbc, 0x9d71b9b9, 0x92c51701]
-    expect(result).toHaveLength(4);
-
-    // Convert to hex and verify
-    const hexResult = result
-      .map((n) => (n >>> 0).toString(16).padStart(8, '0'))
-      .join('');
-    // Note: the hex function reverses byte order, so we need to account for that
-    // For now, just verify we get consistent results
-    expect(hexResult).toBeDefined();
-  });
-
-  test('should handle strings longer than 64 characters', () => {
-    const longString = 'a'.repeat(100);
-    const result = md51(longString);
-
-    expect(result).toHaveLength(4);
-    result.forEach((val) => {
-      expect(Number.isInteger(val)).toBe(true);
-    });
-  });
-
-  test('should handle strings exactly 64 characters', () => {
-    const exact64 = 'a'.repeat(64);
-    const result = md51(exact64);
-
-    expect(result).toHaveLength(4);
-  });
-
-  test('should handle custom add32 functions', () => {
-    const customAdd32 = (x: number, y: number) => (x + y) & 0xffffffff;
-    const result = md51('test', customAdd32);
-
-    expect(result).toHaveLength(4);
-  });
-
-  test('should handle strings with special characters', () => {
-    const testCases = [
-      'Hello, World!',
-      '1234567890',
-      '!@#$%^&*()',
-      'Привет мир', // Cyrillic text
-      '\n\t\r' // Control characters
-    ];
-
-    testCases.forEach((input) => {
-      const result = md51(input);
-      expect(result).toHaveLength(4);
-      result.forEach((val) => {
-        expect(Number.isInteger(val)).toBe(true);
-      });
-    });
-  });
-});

package/__tests__/md5block.test.ts

@@ -1,61 +0,0 @@
-import md5blk from '../src/md5blk';
-
-describe('md5blk', () => {
-  test('should convert string to 16-word block', () => {
-    // Test with a simple string
-    const input = 'a'.repeat(64); // 64 characters = 1 full block
-    const result = md5blk(input);
-
-    expect(result).toHaveLength(16);
-
-    // The character 'a' has code 97
-    // In little-endian, first word should be: 97 + (97 << 8) + (97 << 16) + (97 << 24)
-    const expectedFirstWord = 97 + (97 << 8) + (97 << 16) + (97 << 24);
-    expect(result[0]).toBe(expectedFirstWord);
-  });
-
-  test('should handle empty string', () => {
-    const result = md5blk('');
-    expect(result).toHaveLength(16);
-
-    // All words should be 0
-    for (let i = 0; i < 16; i++) {
-      expect(result[i]).toBe(0);
-    }
-  });
-
-  test('should handle partial block', () => {
-    // Test with less than 64 characters
-    // Note: md5blk always processes 64 characters, padding with null bytes
-    const input = 'hello world';
-    const result = md5blk(input);
-
-    expect(result).toHaveLength(16);
-
-    // First word should contain 'h' (104), 'e' (101), 'l' (108), 'l' (108)
-    const expectedFirstWord = 104 + (101 << 8) + (108 << 16) + (108 << 24);
-    expect(result[0]).toBe(expectedFirstWord);
-
-    // Second word should contain 'o' (111), ' ' (32), 'w' (119), 'o' (111)
-    const expectedSecondWord = 111 + (32 << 8) + (119 << 16) + (111 << 24);
-    expect(result[1]).toBe(expectedSecondWord);
-
-    // Third word should contain 'r' (114), 'l' (108), 'd' (100), null (0)
-    const expectedThirdWord = 114 + (108 << 8) + (100 << 16) + (0 << 24);
-    expect(result[2]).toBe(expectedThirdWord);
-  });
-
-  test('should convert characters correctly', () => {
-    const input = 'abcd';
-    const result = md5blk(input);
-
-    // 'a'(97), 'b'(98), 'c'(99), 'd'(100)
-    const expectedWord = 97 + (98 << 8) + (99 << 16) + (100 << 24);
-    expect(result[0]).toBe(expectedWord);
-
-    // Remaining words should be 0
-    for (let i = 1; i < 16; i++) {
-      expect(result[i]).toBe(0);
-    }
-  });
-});

package/__tests__/md5cycle.test.ts

@@ -1,48 +0,0 @@
-import md5cycle from '../src/md5cycle';
-
-describe('md5cycle', () => {
-  test('should update state correctly', () => {
-    const state = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476];
-    const block = new Array(16).fill(0);
-
-    // Make a copy for comparison
-    const originalState = [...state];
-
-    md5cycle(state, block);
-
-    // After processing, state should be different
-    expect(state).not.toEqual(originalState);
-
-    // All elements should be 32-bit integers
-    state.forEach((val) => {
-      expect(Number.isInteger(val)).toBe(true);
-      expect(val).toBeGreaterThanOrEqual(-0x80000000);
-      expect(val).toBeLessThanOrEqual(0xffffffff);
-    });
-  });
-
-  test('should handle custom add32 functions', () => {
-    const state = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476];
-    const block = new Array(16).fill(0x12345678);
-
-    const customAdd32 = jest.fn((x: number, y: number) => (x + y) & 0xffffffff);
-
-    md5cycle(state, block, customAdd32);
-
-    // Custom add32 function should have been called
-    expect(customAdd32).toHaveBeenCalled();
-  });
-
-  test('should use default add32 when fn is undefined', () => {
-    const state = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476];
-    const block = new Array(16).fill(0);
-
-    // Since we can't easily mock the default import in md5cycle,
-    // we'll test the behavior by ensuring state changes
-    const originalState = [...state];
-
-    md5cycle(state, block);
-
-    expect(state).not.toEqual(originalState);
-  });
-});