pure-md5 0.2.0 → 0.2.1

package/__tests__/stream/md5-stream-edge-cases.test.ts

@@ -1,461 +0,0 @@
-/**
- * Comprehensive edge case tests for MD5Stream
- * Tests public methods, edge cases, and advanced functionality
- */
-
-import { MD5Stream, createMD5Stream } from '../../src/stream/md5-stream.js';
-import { md5Core } from '../../src/core/index.js';
-
-describe('MD5Stream - Public Methods', () => {
-  describe('getCurrentState()', () => {
-    test('should return initial state on new instance', () => {
-      const stream = new MD5Stream();
-      const state = stream.getCurrentState();
-      
-      expect(state.state).toHaveLength(4);
-      expect(state.state[0]).toBe(1732584193);
-      expect(state.state[1]).toBe(-271733879);
-      expect(state.state[2]).toBe(-1732584194);
-      expect(state.state[3]).toBe(271733878);
-      expect(state.bytesProcessed).toBe(0);
-    });
-
-    test('should update state after processing data', () => {
-      const stream = new MD5Stream();
-      // Use data larger than 64 bytes to trigger actual processing
-      stream.write('a'.repeat(70));
-      const state = stream.getCurrentState();
-      
-      expect(state.bytesProcessed).toBeGreaterThan(0);
-      expect(state.state).not.toEqual([1732584193, -271733879, -1732584194, 271733878]);
-    });
-
-    test('should not modify internal state on multiple calls', () => {
-      const stream = new MD5Stream();
-      stream.write('test');
-      
-      const state1 = stream.getCurrentState();
-      const state2 = stream.getCurrentState();
-      const state3 = stream.getCurrentState();
-      
-      expect(state1).toEqual(state2);
-      expect(state2).toEqual(state3);
-    });
-
-    test('should return deep copy of state', () => {
-      const stream = new MD5Stream();
-      const state1 = stream.getCurrentState();
-      
-      // Modify returned state
-      state1.state[0] = 0;
-      state1.bytesProcessed = 999;
-      
-      // Original should be unchanged
-      const state2 = stream.getCurrentState();
-      expect(state2.state[0]).not.toBe(0);
-      expect(state2.bytesProcessed).not.toBe(999);
-    });
-  });
-
-  describe('getBytesProcessed()', () => {
-    test('should return 0 for new instance', () => {
-      const stream = new MD5Stream();
-      expect(stream.getBytesProcessed()).toBe(0);
-    });
-
-    test('should increment with data chunks', () => {
-      const stream = new MD5Stream();
-      
-      expect(stream.getBytesProcessed()).toBe(0);
-      stream.write('ab');
-      expect(stream.getBytesProcessed()).toBe(2);
-      stream.write('cd');
-      expect(stream.getBytesProcessed()).toBe(4);
-    });
-
-    test('should not include pending buffer bytes', () => {
-      const stream = new MD5Stream();
-      
-      // Write partial block (less than 64 bytes)
-      const partial = 'a'.repeat(32);
-      stream.write(partial);
-      
-      // Should count exact bytes written
-      expect(stream.getBytesProcessed()).toBe(32);
-    });
-  });
-
-  describe('reset()', () => {
-    test('should reset state to initial values', () => {
-      const stream = new MD5Stream();
-      stream.write('test data that will be reset');
-      
-      stream.reset();
-      
-      const state = stream.getCurrentState();
-      expect(state.state[0]).toBe(1732584193);
-      expect(state.bytesProcessed).toBe(0);
-    });
-
-    test('should allow reusing stream after reset', (done) => {
-      const stream = new MD5Stream();
-      let firstDone = false;
-      let secondDone = false;
-      
-      stream.on('md5', (result) => {
-        if (!firstDone) {
-          // First computation complete
-          expect(result.digest).toBe(md5Core('first'));
-          expect(result.bytesProcessed).toBe(5);
-          firstDone = true;
-          
-          // Reset the stream state
-          stream.reset();
-          
-          // Now we need to write new data
-          // But stream is already ended, so we can't use it
-          // This test verifies that reset() clears the internal state
-          // For full reuse, you need to create a new stream
-        } else if (!secondDone) {
-          // Second computation would be on a fresh stream
-          secondDone = true;
-        }
-      });
-      
-      stream.write('first');
-      stream.end();
-      
-      // Verify reset worked by checking state is cleared
-      setTimeout(() => {
-        const state = stream.getCurrentState();
-        expect(state.bytesProcessed).toBe(0);
-        done();
-      }, 100);
-    });
-  });
-});
-
-describe('MD5Stream - Edge Cases', () => {
-  describe('Empty and Zero-length Data', () => {
-    test('should handle completely empty stream', (done) => {
-      const stream = new MD5Stream();
-      
-      stream.on('md5', (result) => {
-        expect(result.digest).toBe(md5Core(''));
-        expect(result.bytesProcessed).toBe(0);
-        done();
-      });
-      
-      stream.end();
-    });
-
-    test('should handle stream with only empty writes', (done) => {
-      const stream = new MD5Stream();
-      
-      stream.on('md5', (result) => {
-        expect(result.digest).toBe(md5Core(''));
-        expect(result.bytesProcessed).toBe(0);
-        done();
-      });
-      
-      stream.write('');
-      stream.write('');
-      stream.end();
-    });
-
-    test('should handle mix of empty and non-empty writes', (done) => {
-      const stream = new MD5Stream();
-      const input = 'test';
-      
-      stream.on('md5', (result) => {
-        expect(result.digest).toBe(md5Core(input)); // MD5 of string using charCodeAt (matches Node.js string encoding)
-        expect(result.bytesProcessed).toBe(4);
-        done();
-      });
-      
-      stream.write('');
-      stream.write('te');
-      stream.write('');
-      stream.write('st');
-      stream.write('');
-      stream.end();
-    });
-  });
-
-  describe('Single Byte Processing', () => {
-    test('should handle single byte string', (done) => {
-      const stream = new MD5Stream();
-      
-      stream.on('md5', (result) => {
-        expect(result.digest).toBe(md5Core('a'));
-        expect(result.bytesProcessed).toBe(1);
-        done();
-      });
-      
-      stream.write('a');
-      stream.end();
-    });
-
-    test('should handle single byte buffer', (done) => {
-      const stream = new MD5Stream();
-      
-      stream.on('md5', (result) => {
-        expect(result.digest).toBe(md5Core('x'));
-        expect(result.bytesProcessed).toBe(1);
-        done();
-      });
-      
-      stream.write(Buffer.from('x'));
-      stream.end();
-    });
-
-    test('should process 64 single-byte chunks correctly', (done) => {
-      const stream = new MD5Stream();
-      const input = Array(64).fill('a').join('');
-      
-      stream.on('md5', (result) => {
-        expect(result.digest).toBe(md5Core(input)); // MD5 of string using charCodeAt (matches Node.js string encoding)
-        expect(result.bytesProcessed).toBe(64);
-        done();
-      });
-      
-      for (let i = 0; i < 64; i++) {
-        stream.write('a');
-      }
-      stream.end();
-    });
-  });
-
-  describe('Boundary Conditions', () => {
-    test('should handle exactly 64 bytes (one block)', (done) => {
-      const stream = new MD5Stream();
-      const input = 'a'.repeat(64);
-      
-      stream.on('md5', (result) => {
-        expect(result.digest).toBe(md5Core(input)); // MD5 of string using charCodeAt (matches Node.js string encoding)
-        expect(result.bytesProcessed).toBe(64);
-        done();
-      });
-      
-      stream.end(input);
-    });
-
-    test('should handle exactly 128 bytes (two blocks)', (done) => {
-      const stream = new MD5Stream();
-      const input = 'a'.repeat(128);
-      
-      stream.on('md5', (result) => {
-        expect(result.digest).toBe(md5Core(input)); // MD5 of string using charCodeAt (matches Node.js string encoding)
-        expect(result.bytesProcessed).toBe(128);
-        done();
-      });
-      
-      stream.end(input);
-    });
-
-    test('should handle 63 bytes (one byte short of block)', (done) => {
-      const stream = new MD5Stream();
-      const input = 'a'.repeat(63);
-      
-      stream.on('md5', (result) => {
-        expect(result.digest).toBe(md5Core(input)); // MD5 of string using charCodeAt (matches Node.js string encoding)
-        expect(result.bytesProcessed).toBe(63);
-        done();
-      });
-      
-      stream.end(input);
-    });
-
-    test('should handle 65 bytes (one byte over block)', (done) => {
-      const stream = new MD5Stream();
-      const input = 'a'.repeat(65);
-      
-      stream.on('md5', (result) => {
-        expect(result.digest).toBe(md5Core(input)); // MD5 of string using charCodeAt (matches Node.js string encoding)
-        expect(result.bytesProcessed).toBe(65);
-        done();
-      });
-      
-      stream.end(input);
-    });
-
-    test('should handle 127 bytes (one byte short of 2 blocks)', (done) => {
-      const stream = new MD5Stream();
-      const input = 'a'.repeat(127);
-      
-      stream.on('md5', (result) => {
-        expect(result.digest).toBe(md5Core(input)); // MD5 of string using charCodeAt (matches Node.js string encoding)
-        expect(result.bytesProcessed).toBe(127);
-        done();
-      });
-      
-      stream.end(input);
-    });
-
-    test('should handle 129 bytes (one byte over 2 blocks)', (done) => {
-      const stream = new MD5Stream();
-      const input = 'a'.repeat(129);
-      
-      stream.on('md5', (result) => {
-        expect(result.digest).toBe(md5Core(input)); // MD5 of string using charCodeAt (matches Node.js string encoding)
-        expect(result.bytesProcessed).toBe(129);
-        done();
-      });
-      
-      stream.end(input);
-    });
-  });
-
-  describe('Very Large Data', () => {
-    test('should handle 1MB of data', (done) => {
-      const stream = new MD5Stream();
-      const size = 1024 * 1024; // 1MB
-      const input = 'a'.repeat(size);
-      
-      stream.on('md5', (result) => {
-        expect(result.digest).toBe(md5Core(input)); // MD5 of string using charCodeAt (matches Node.js string encoding)
-        expect(result.bytesProcessed).toBe(size);
-        done();
-      });
-      
-      stream.end(input);
-    }, 10000);
-
-    test('should handle 10MB of data', (done) => {
-      const stream = new MD5Stream();
-      const size = 10 * 1024 * 1024; // 10MB
-      const input = 'a'.repeat(size);
-      
-      stream.on('md5', (result) => {
-        expect(result.bytesProcessed).toBe(size);
-        expect(result.digest.length).toBe(32);
-        done();
-      });
-      
-      stream.end(input);
-    }, 30000);
-  });
-});
-
-describe('MD5Stream - State Management', () => {
-  test('should maintain state across multiple chunks', (done) => {
-    const stream = new MD5Stream();
-    const input = 'The quick brown fox jumps over the lazy dog';
-    const chunks = [
-      'The qu',
-      'ick bro',
-      'wn fox ju',
-      'mps over ',
-      'the lazy d',
-      'og'
-    ];
-    
-    stream.on('md5', (result) => {
-      expect(result.digest).toBe(md5Core(input)); // MD5 of string using charCodeAt (matches Node.js string encoding)
-      expect(result.bytesProcessed).toBe(input.length);
-      done();
-    });
-    
-    chunks.forEach(chunk => stream.write(chunk));
-    stream.end();
-  });
-
-  test('should maintain state with alternating chunk sizes', (done) => {
-    const stream = new MD5Stream();
-    const input = 'abcdefghijklmnopqrstuvwxyz';
-    
-    stream.on('md5', (result) => {
-      expect(result.digest).toBe(md5Core(input)); // MD5 of string using charCodeAt (matches Node.js string encoding)
-      expect(result.bytesProcessed).toBe(26);
-      done();
-    });
-    
-    // Alternating very small and larger chunks
-    stream.write('ab');
-    stream.write('cdefghijklmnop');
-    stream.write('qr');
-    stream.write('stuvwxyz');
-    stream.end();
-  });
-});
-
-describe('MD5Stream - Custom Options', () => {
-  test('should work with custom add32 function', (done) => {
-    const customAdd32 = (x: number, y: number): number => {
-      // Custom implementation that matches standard behavior
-      return ((x + y) & 0xffffffff);
-    };
-    
-    const stream = new MD5Stream({ add32: customAdd32 });
-    const input = 'custom add32 test string';
-    
-    stream.on('md5', (result) => {
-      // Should produce same result as default add32
-      expect(result.digest).toBe(md5Core(input)); // MD5 of string using charCodeAt (matches Node.js string encoding)
-      expect(result.bytesProcessed).toBe(input.length);
-      done();
-    });
-    
-    stream.end(input);
-  });
-});
-
-describe('MD5Stream - Factory Functions', () => {
-  test('createMD5Stream should return valid instance', () => {
-    const stream = createMD5Stream();
-    expect(stream).toBeInstanceOf(MD5Stream);
-    expect(stream.getCurrentState().bytesProcessed).toBe(0);
-  });
-
-  test('createMD5Stream should support options', () => {
-    const customAdd32 = (x: number, y: number): number => (x + y) & 0xffffffff;
-    const stream = createMD5Stream({ add32: customAdd32 });
-    
-    expect(stream).toBeInstanceOf(MD5Stream);
-    expect(stream.getCurrentState().bytesProcessed).toBe(0);
-  });
-});
-
-describe('MD5Stream - Special Characters', () => {
-  test('should handle null bytes', (done) => {
-    const stream = new MD5Stream();
-    const input = 'a\0b\0c\0d';
-    
-    stream.on('md5', (result) => {
-      expect(result.digest).toBe(md5Core(input)); // MD5 of string using charCodeAt (matches Node.js string encoding)
-      expect(result.bytesProcessed).toBe(input.length);
-      done();
-    });
-    
-    stream.end(input);
-  });
-
-  test('should handle unicode characters', (done) => {
-    const stream = new MD5Stream();
-    const input = 'Привет мир 🌍'; // "Hello world" in Russian + emoji
-    
-    stream.on('md5', (result) => {
-      // Stream uses UTF-8 encoding for strings (via Node.js Buffer)
-      // Expected hash is MD5 of UTF-8 bytes
-      expect(result.digest).toBe('c3f46b3563baa69fc33b2830242e11b1'); // MD5 of UTF-8 bytes
-      // bytesProcessed is UTF-8 byte length (24 bytes for this string)
-      expect(result.bytesProcessed).toBe(24); // UTF-8 byte length
-      done();
-    });
-    
-    stream.end(input);
-  });
-
-  test('should handle control characters', (done) => {
-    const stream = new MD5Stream();
-    const input = '\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f';
-    
-    stream.on('md5', (result) => {
-      expect(result.digest).toBe(md5Core(input)); // MD5 of string using charCodeAt (matches Node.js string encoding)
-      expect(result.bytesProcessed).toBe(16);
-      done();
-    });
-    
-    stream.end(input);
-  });
-});