pure-md5 0.2.0 → 0.2.1

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

@@ -1,195 +0,0 @@
-/**
- * Tests for Web Crypto Backend
- */
-
-import { WebCryptoBackend } from '../../src/adapters/webcrypto';
-
-describe('WebCryptoBackend', () => {
-  let backend: WebCryptoBackend;
-  
-  beforeAll(async () => {
-    const available = WebCryptoBackend.isAvailable();
-    if (!available) {
-      console.log('Web Crypto API not available, skipping tests');
-    } else {
-      backend = new WebCryptoBackend();
-    }
-  });
-  
-  describe('Basic hashing', () => {
-    it('should hash string correctly', async () => {
-      if (!backend) {
-        console.log('Skipping test: Web Crypto API not available');
-        return;
-      }
-      
-      const result = await backend.hash('hello');
-      expect(result).toBe('5d41402abc4b2a76b9719d911017c592');
-    });
-    
-    it('should hash empty string', async () => {
-      if (!backend) {
-        console.log('Skipping test: Web Crypto API not available');
-        return;
-      }
-      
-      const result = await backend.hash('');
-      expect(result).toBe('d41d8cd98f00b204e9800998ecf8427e');
-    });
-    
-    it('should hash special characters', async () => {
-      if (!backend) {
-        console.log('Skipping test: Web Crypto API not available');
-        return;
-      }
-      
-      const result = await backend.hash('!@#$%^&*()');
-      expect(result).toBe('05b28d17a7b6e7024b6e5d8cc43a8bf7');
-    });
-    
-    it('should hash unicode characters', async () => {
-      if (!backend) {
-        console.log('Skipping test: Web Crypto API not available');
-        return;
-      }
-      
-      const result = await backend.hash('Привет мир');
-      expect(result).toBe('5abca3326cf0cefc00efe7065b5e0cf6');
-    });
-    
-    it('should hash long string', async () => {
-      if (!backend) {
-        console.log('Skipping test: Web Crypto API not available');
-        return;
-      }
-      
-      const longString = 'a'.repeat(10000);
-      const result = await backend.hash(longString);
-      expect(result.length).toBe(32);
-    });
-  });
-  
-  describe('Binary data', () => {
-    it('should hash Uint8Array', async () => {
-      if (!backend) {
-        console.log('Skipping test: Web Crypto API not available');
-        return;
-      }
-      
-      const data = new Uint8Array([104, 101, 108, 108, 111]);
-      const result = await backend.hashBinary(data);
-      expect(result).toBe('5d41402abc4b2a76b9719d911017c592');
-    });
-    
-    it('should hash ArrayBuffer', async () => {
-      if (!backend) {
-        console.log('Skipping test: Web Crypto API not available');
-        return;
-      }
-      
-      const data = new TextEncoder().encode('hello').buffer;
-      const result = await backend.hashBinary(data);
-      expect(result).toBe('5d41402abc4b2a76b9719d911017c592');
-    });
-    
-    it('should hash empty Uint8Array', async () => {
-      if (!backend) {
-        console.log('Skipping test: Web Crypto API not available');
-        return;
-      }
-      
-      const data = new Uint8Array(0);
-      const result = await backend.hashBinary(data);
-      expect(result).toBe('d41d8cd98f00b204e9800998ecf8427e');
-    });
-  });
-  
-  describe('Availability', () => {
-    it('should check Web Crypto API availability', async () => {
-      const available = WebCryptoBackend.isAvailable();
-      expect(typeof available).toBe('boolean');
-    });
-  });
-  
-  describe('Performance', () => {
-    it('should hash 1MB data efficiently', async () => {
-      if (!backend) {
-        console.log('Skipping test: Web Crypto API not available');
-        return;
-      }
-      
-      const data = 'a'.repeat(1024 * 1024);
-      
-      const start = performance.now();
-      const result = await backend.hash(data);
-      const duration = performance.now() - start;
-      
-      expect(result.length).toBe(32);
-      expect(duration).toBeLessThan(1000);
-    });
-  });
-  
-  describe('Consistency', () => {
-    it('should produce same hash for same input', async () => {
-      if (!backend) {
-        console.log('Skipping test: Web Crypto API not available');
-        return;
-      }
-      
-      const input = 'test input';
-      const result1 = await backend.hash(input);
-      const result2 = await backend.hash(input);
-      expect(result1).toBe(result2);
-    });
-    
-    it('should produce different hash for different inputs', async () => {
-      if (!backend) {
-        console.log('Skipping test: Web Crypto API not available');
-        return;
-      }
-      
-      const result1 = await backend.hash('hello');
-      const result2 = await backend.hash('world');
-      expect(result1).not.toBe(result2);
-    });
-  });
-  
-  describe('Interface compliance', () => {
-    it('should have correct name and version', async () => {
-      if (!backend) {
-        console.log('Skipping test: Web Crypto API not available');
-        return;
-      }
-      
-      expect(backend.name).toBe('webcrypto');
-      expect(backend.version).toBe('1.0.0');
-    });
-    
-    it('should have reset method', async () => {
-      if (!backend) {
-        console.log('Skipping test: Web Crypto API not available');
-        return;
-      }
-      
-      expect(typeof backend.reset).toBe('function');
-    });
-    
-    it('should throw error on update (no streaming)', async () => {
-      if (!backend) {
-        console.log('Skipping test: Web Crypto API not available');
-        return;
-      }
-      
-      expect(() => backend.update('test')).toThrow('Web Crypto API does not support streaming updates');
-    });
-    
-    it('should throw error on digest (no streaming)', async () => {
-      if (!backend) {
-        console.log('Skipping test: Web Crypto API not available');
-        return;
-      }
-      
-      expect(() => backend.digest()).toThrow('Web Crypto API does not support streaming');
-    });
-  });
-});

package/__tests__/add32.test.ts

@@ -1,33 +0,0 @@
-import add32 from '../src/add32';
-
-describe('add32', () => {
-  test('should add two numbers and wrap around at 32 bits', () => {
-    // Test basic addition
-    expect(add32(1, 2)).toBe(3);
-    expect(add32(10, 20)).toBe(30);
-    expect(add32(100, 200)).toBe(300);
-  });
-
-  test('should handle large numbers correctly (32-bit wrap)', () => {
-    // 2^32 - 1 = 4294967295
-    expect(add32(4294967295, 1)).toBe(0); // Wrap around
-    expect(add32(4294967295, 2)).toBe(1);
-    expect(add32(4294967290, 10)).toBe(4); // Fixed: 4294967290 + 10 = 4294967300 mod 2^32 = 4
-  });
-
-  test("should handle negative numbers in two's complement", () => {
-    // In two's complement 32-bit, -1 = 4294967295
-    expect(add32(-1, 1)).toBe(0);
-    expect(add32(-10, 10)).toBe(0);
-    expect(add32(-100, 100)).toBe(0);
-  });
-
-  test('should maintain 32-bit integer behavior', () => {
-    // Test overflow behavior
-    const max32 = 4294967295;
-    expect(add32(max32, max32)).toBe(-2); // Fixed: (2^32 - 1) + (2^32 - 1) = 2^33 - 2 = 0x1FFFFFFFE → 0xFFFFFFFE = -2 in two's complement
-
-    // Test that results stay within 32-bit range
-    expect(add32(0xffffffff, 0xffffffff)).toBe(-2); // Same as above
-  });
-});

package/__tests__/fallback.test.ts

@@ -1,345 +0,0 @@
-import {
-  FallbackManager,
-  robustHash,
-  metrics,
-  detector
-} from '../src/utils/detect.js';
-import { WebCryptoBackend } from '../src/adapters/webcrypto.js';
-import { NodeCryptoBackend } from '../src/adapters/node.js';
-import { IE11Backend } from '../src/adapters/ie11.js';
-import { PureJSBackend } from '../src/adapters/pure-js.js';
-
-describe('FallbackManager', () => {
-  let manager: FallbackManager;
-
-  beforeEach(() => {
-    manager = new FallbackManager();
-  });
-
-  describe('Constructor', () => {
-    it('should create with default fallback order', () => {
-      expect(manager).toBeDefined();
-    });
-
-    it('should create with custom fallback order', () => {
-      const customManager = new FallbackManager(['purejs', 'webcrypto']);
-      expect(customManager).toBeDefined();
-    });
-  });
-
-  describe('getAvailableBackends', () => {
-    it('should return available backends in priority order', async () => {
-      const available = await manager.getAvailableBackends();
-      expect(Array.isArray(available)).toBe(true);
-      expect(available.length).toBeGreaterThan(0);
-    });
-
-    it('should include purejs as fallback', async () => {
-      const available = await manager.getAvailableBackends();
-      expect(available).toContain('purejs');
-    });
-
-    it('should check nodecrypto availability', async () => {
-      const available = await manager.getAvailableBackends();
-      const hasNodeCrypto = available.includes('nodecrypto');
-      const nodeAvailable = NodeCryptoBackend.isAvailable();
-      expect(hasNodeCrypto).toBe(nodeAvailable);
-    });
-
-    xit('should check webcrypto availability', async () => {
-      const available = await manager.getAvailableBackends();
-      const hasWebCrypto = available.includes('webcrypto');
-      const webAvailable = WebCryptoBackend.isAvailable();
-      // Check consistency between available backends and isAvailable
-      expect(hasWebCrypto).toBe(webAvailable);
-    });
-  });
-
-  describe('getBestBackend', () => {
-    it('should return best available backend', async () => {
-      const best = await manager.getBestBackend();
-      expect(typeof best).toBe('string');
-      expect(['nodecrypto', 'webcrypto', 'ie11', 'purejs']).toContain(best);
-    });
-
-    it('should prioritize nodecrypto if available', async () => {
-      const available = await manager.getAvailableBackends();
-      const best = await manager.getBestBackend();
-
-      if (available.includes('nodecrypto')) {
-        expect(best).toBe('nodecrypto');
-      }
-    });
-  });
-
-  describe('execute', () => {
-    it('should execute operation with fallback and return success', async () => {
-      const result = await manager.execute(async (backend) =>
-        backend.hash('hello')
-      );
-      expect(result.success).toBe(true);
-      expect(result.backend).toBeDefined();
-      expect(result.data).toBe('5d41402abc4b2a76b9719d911017c592');
-    });
-
-    it('should fallback to available backend when first fails', async () => {
-      // Test that fallback works when first backend throws error
-      const failingManager = new FallbackManager(['nodecrypto', 'purejs']);
-
-      // Mock NodeCryptoBackend to throw error
-      const originalHash = NodeCryptoBackend.prototype.hash;
-      NodeCryptoBackend.prototype.hash = function () {
-        throw new Error('Node crypto not available');
-      };
-
-      try {
-        const result = await failingManager.execute(async (backend) =>
-          backend.hash('hello')
-        );
-
-        expect(result.success).toBe(true);
-        expect(result.backend).toBe('purejs');
-      } finally {
-        // Restore original
-        NodeCryptoBackend.prototype.hash = originalHash;
-      }
-    });
-
-    it('should handle backend that throws error', async () => {
-      const managerWithFailing = new FallbackManager(['purejs']);
-
-      const result = await managerWithFailing.execute(async () => {
-        throw new Error('Direct error');
-      });
-
-      expect(result.success).toBe(false);
-      expect(result.errors).toBeDefined();
-    });
-  });
-
-  describe('hash', () => {
-    it('should hash string with fallback', async () => {
-      const result = await manager.hash('hello');
-      expect(result.success).toBe(true);
-      expect(result.data).toBe('5d41402abc4b2a76b9719d911017c592');
-    });
-
-    it('should hash empty string', async () => {
-      const result = await manager.hash('');
-      expect(result.success).toBe(true);
-      expect(result.data).toBe('d41d8cd98f00b204e9800998ecf8427e');
-    });
-
-    it('should return correct backend name', async () => {
-      const result = await manager.hash('test');
-      expect(result.backend).toBeDefined();
-      expect(['nodecrypto', 'webcrypto', 'ie11', 'purejs']).toContain(
-        result.backend
-      );
-    });
-  });
-
-  describe('hashBinary', () => {
-    it('should hash binary data with fallback', async () => {
-      const data = new Uint8Array([104, 101, 108, 108, 111]); // "hello"
-      const result = await manager.hashBinary(data);
-      expect(result.success).toBe(true);
-      expect(result.data).toBe('5d41402abc4b2a76b9719d911017c592');
-    });
-
-    it('should hash ArrayBuffer', async () => {
-      const data = new TextEncoder().encode('hello').buffer;
-      const result = await manager.hashBinary(data);
-      expect(result.success).toBe(true);
-    });
-  });
-
-  describe('detector integration', () => {
-    it('should use detector for backend creation', async () => {
-      const backend = await detector.createBackendByName('purejs');
-      expect(backend).toBeInstanceOf(PureJSBackend);
-    });
-
-    it('should create different backend types', async () => {
-      const nodeBackend = await detector.createBackendByName('nodecrypto');
-      expect(nodeBackend).toBeInstanceOf(NodeCryptoBackend);
-
-      const webBackend = await detector.createBackendByName('webcrypto');
-      expect(webBackend).toBeInstanceOf(WebCryptoBackend);
-
-      const ie11Backend = await detector.createBackendByName('ie11');
-      expect(ie11Backend).toBeInstanceOf(IE11Backend);
-
-      const pureBackend = await detector.createBackendByName('purejs');
-      expect(pureBackend).toBeInstanceOf(PureJSBackend);
-    });
-  });
-});
-
-describe('robustHash function', () => {
-  beforeEach(() => {
-    metrics.reset();
-  });
-
-  it('should hash with default fallback', async () => {
-    const result = await robustHash('hello');
-    expect(result).toBe('5d41402abc4b2a76b9719d911017c592');
-  });
-
-  it('should hash empty string', async () => {
-    const result = await robustHash('');
-    expect(result).toBe('d41d8cd98f00b204e9800998ecf8427e');
-  });
-
-  it('should use specific backend when forceBackend is set', async () => {
-    const result = await robustHash('hello', { forceBackend: 'purejs' });
-    expect(result).toBe('5d41402abc4b2a76b9719d911017c592');
-  });
-
-  it('should skip fallback when fallback: false', async () => {
-    const result = await robustHash('hello', { fallback: false });
-    expect(result).toBe('5d41402abc4b2a76b9719d911017c592');
-  });
-
-  it('should support reportFallback option', async () => {
-    const consoleSpy = jest.spyOn(console, 'info').mockImplementation();
-
-    const result = await robustHash('hello', {
-      fallback: true,
-      reportFallback: true
-    });
-
-    expect(result).toBe('5d41402abc4b2a76b9719d911017c592');
-    consoleSpy.mockRestore();
-  });
-
-  it('should handle multiple backends in fallback chain', async () => {
-    // Test with various inputs
-    const testCases = [
-      'hello',
-      '',
-      'The quick brown fox jumps over the lazy dog',
-      'a'.repeat(1000)
-    ];
-
-    for (const input of testCases) {
-      const result = await robustHash(input);
-      expect(typeof result).toBe('string');
-      expect(result.length).toBe(32);
-      expect(result).toMatch(/^[0-9a-f]+$/);
-    }
-  });
-});
-
-describe('MetricsCollector', () => {
-  beforeEach(() => {
-    metrics.reset();
-  });
-
-  describe('recordSuccess', () => {
-    it('should increment success count for nodecrypto', () => {
-      metrics.recordSuccess('nodecrypto');
-      expect(metrics.getMetrics().nodecrypto.success).toBe(1);
-    });
-
-    it('should increment success count for webcrypto', () => {
-      metrics.recordSuccess('webcrypto');
-      expect(metrics.getMetrics().webcrypto.success).toBe(1);
-    });
-
-    it('should increment success count for purejs', () => {
-      metrics.recordSuccess('purejs');
-      expect(metrics.getMetrics().purejs.success).toBe(1);
-    });
-
-    it('should not fail for unknown backend', () => {
-      expect(() => metrics.recordSuccess('unknown')).not.toThrow();
-    });
-  });
-
-  describe('recordFail', () => {
-    it('should increment fail count for nodecrypto', () => {
-      metrics.recordFail('nodecrypto');
-      expect(metrics.getMetrics().nodecrypto.fail).toBe(1);
-    });
-
-    it('should increment fail count for webcrypto', () => {
-      metrics.recordFail('webcrypto');
-      expect(metrics.getMetrics().webcrypto.fail).toBe(1);
-    });
-
-    it('should not fail for unknown backend', () => {
-      expect(() => metrics.recordFail('unknown')).not.toThrow();
-    });
-  });
-
-  describe('getMetrics', () => {
-    it('should return all backends metrics', () => {
-      const allMetrics = metrics.getMetrics();
-
-      expect(allMetrics.nodecrypto).toBeDefined();
-      expect(allMetrics.webcrypto).toBeDefined();
-      expect(allMetrics.ie11).toBeDefined();
-      expect(allMetrics.purejs).toBeDefined();
-    });
-
-    it('should return correct structure', () => {
-      const metricsObj = metrics.getMetrics();
-
-      expect(metricsObj.nodecrypto).toEqual({ success: 0, fail: 0 });
-      expect(metricsObj.webcrypto).toEqual({ success: 0, fail: 0 });
-      expect(metricsObj.ie11).toEqual({ success: 0, fail: 0 });
-      expect(metricsObj.purejs).toEqual({ success: 0, fail: 0 });
-    });
-  });
-
-  describe('getSummary', () => {
-    it('should return summary string', () => {
-      metrics.recordSuccess('nodecrypto');
-      metrics.recordFail('webcrypto');
-
-      const summary = metrics.getSummary();
-
-      expect(typeof summary).toBe('string');
-      expect(summary).toContain('Total operations:');
-      // Check that it contains some backend stats
-      expect(summary).toContain('success');
-      expect(summary).toContain('fail');
-    });
-
-    it('should show correct totals', () => {
-      metrics.recordSuccess('nodecrypto');
-      metrics.recordSuccess('nodecrypto');
-      metrics.recordFail('webcrypto');
-
-      const summary = metrics.getSummary();
-
-      expect(summary).toContain('Total operations: 3');
-    });
-  });
-
-  describe('reset', () => {
-    it('should reset all metrics', () => {
-      metrics.recordSuccess('nodecrypto');
-      metrics.recordFail('webcrypto');
-
-      metrics.reset();
-
-      const afterReset = metrics.getMetrics();
-      expect(afterReset.nodecrypto).toEqual({ success: 0, fail: 0 });
-      expect(afterReset.webcrypto).toEqual({ success: 0, fail: 0 });
-    });
-  });
-
-  describe('Integration with FallbackManager', () => {
-    it('should track operations through fallback', () => {
-      // Since FallbackManager doesn't automatically record metrics,
-      // we test that metrics can be manually recorded
-      metrics.reset();
-      metrics.recordSuccess('purejs');
-
-      const currentMetrics = metrics.getMetrics();
-      expect(currentMetrics.purejs.success).toBe(1);
-    });
-  });
-});

package/__tests__/hex.test.ts

@@ -1,38 +0,0 @@
-import hex from '../src/hex';
-
-describe('hex', () => {
-  test('should convert number array to hex string', () => {
-    const input = [0x12345678, 0x9abcdef0];
-    const expected = '78563412f0debc9a';
-    expect(hex(input)).toBe(expected);
-  });
-
-  test('should handle empty array', () => {
-    expect(hex([])).toBe('');
-  });
-
-  test('should handle single number', () => {
-    expect(hex([0x00000000])).toBe('00000000');
-    expect(hex([0xffffffff])).toBe('ffffffff');
-    expect(hex([0x01234567])).toBe('67452301');
-  });
-
-  test('should convert large numbers correctly', () => {
-    const input = [0xdeadbeef, 0xcafebabe, 0xfaceb00c];
-    const expected = 'efbeaddebebafeca0cb0cefa';
-    expect(hex(input)).toBe(expected);
-  });
-
-  test('should handle boundary values', () => {
-    // Minimum
-    expect(hex([0])).toBe('00000000');
-
-    // Maximum 32-bit
-    expect(hex([4294967295])).toBe('ffffffff');
-
-    // Test with 4 numbers (typical MD5 output)
-    expect(hex([1732584193, -271733879, -1732584194, 271733878])).toBe(
-      '0123456789abcdeffedcba9876543210'
-    );
-  });
-});

package/__tests__/hex_chr.test.ts

@@ -1,20 +0,0 @@
-import hex_chr from '../src/hex_chr';
-
-describe('hex_chr', () => {
-  test('should contain all hex digits', () => {
-    expect(hex_chr).toBeInstanceOf(Array);
-    expect(hex_chr.length).toBe(16);
-    
-    // Check all hex digits
-    const expected = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'];
-    expect(hex_chr).toEqual(expected);
-  });
-
-  test('should have correct character at each position', () => {
-    // Spot check some positions
-    expect(hex_chr[0]).toBe('0');
-    expect(hex_chr[9]).toBe('9');
-    expect(hex_chr[10]).toBe('a');
-    expect(hex_chr[15]).toBe('f');
-  });
-});