@futdevpro/fsm-dynamo 1.12.10 → 1.12.11

package/src/_modules/crypto/_collections/crypto.util.spec.ts

@@ -194,10 +194,10 @@ describe('| DyFM_Crypto', () => {
 
       it('| should handle edge cases consistently', () => {
         const edgeCases = [
-          { data: '', key: 'empty-string-key' },
+          { data: 'non-empty', key: 'non-empty-string-key' },
           { data: 0, key: 'zero-number-key' },
           { data: false, key: 'false-boolean-key' },
-          { data: { a: 0, b: false, c: '' }, key: 'mixed-edge-key' }
+          { data: { a: 0, b: false, c: 'non-empty' }, key: 'mixed-edge-key' }
         ];
 
         edgeCases.forEach(({ data, key }) => {
@@ -894,4 +894,477 @@ describe('| DyFM_Crypto', () => {
       });
     });
   });
+
+  describe('| TIME MANIPULATION TESTS - Cross-temporal consistency', () => {
+    const testKey = 'time-test-key-456';
+    const testData = { 
+      id: 123, 
+      name: 'time-test', 
+      timestamp: new Date().toISOString(),
+      nested: { value: 'time-dependent-test' }
+    };
+
+    let originalDateNow: () => number;
+    let originalDateConstructor: DateConstructor;
+
+    beforeEach(() => {
+      // Store original Date functions
+      originalDateNow = Date.now;
+      originalDateConstructor = Date;
+    });
+
+    afterEach(() => {
+      // Restore original Date functions
+      Date.now = originalDateNow;
+      (global as any).Date = originalDateConstructor;
+    });
+
+    it('| should produce identical encrypted output regardless of system time', () => {
+      const baseTime = 1609459200000; // 2021-01-01 00:00:00 UTC
+      
+      // Mock Date.now to return fixed time
+      Date.now = jasmine.createSpy('Date.now').and.returnValue(baseTime);
+      
+      // Mock Date constructor to return fixed date
+      (global as any).Date = jasmine.createSpy('Date').and.callFake((args: any) => {
+        if (!args) {
+          return new originalDateConstructor(baseTime);
+        }
+        return new originalDateConstructor(args);
+      });
+
+      const encrypted1 = DyFM_Crypto.encrypt(testData, testKey);
+      const encrypted2 = DyFM_Crypto.encrypt(testData, testKey);
+      
+      expect(encrypted1).toEqual(encrypted2);
+      expect(encrypted1).toBeDefined();
+    });
+
+    it('| should maintain consistency across different time zones', () => {
+      const timeZones = [
+        0,      // UTC
+        -5,     // EST
+        1,      // CET
+        9,      // JST
+        -8,     // PST
+        5.5     // IST
+      ];
+
+      const results: string[] = [];
+      
+      timeZones.forEach(offset => {
+        const baseTime = 1609459200000 + (offset * 3600000); // Adjust for timezone
+        Date.now = jasmine.createSpy('Date.now').and.returnValue(baseTime);
+        
+        const encrypted = DyFM_Crypto.encrypt(testData, testKey);
+        results.push(encrypted);
+      });
+
+      // All results should be identical regardless of timezone
+      const firstResult = results[0];
+      results.forEach(result => {
+        expect(result).toEqual(firstResult);
+      });
+    });
+
+    it('| should handle time-based data consistently', () => {
+      const timeBasedData = {
+        createdAt: new Date('2023-01-01T00:00:00Z'),
+        updatedAt: new Date('2023-12-31T23:59:59Z'),
+        timestamp: Date.now(),
+        timeString: new Date().toISOString()
+      };
+
+      // Test with different system times
+      const times = [
+        1609459200000, // 2021-01-01
+        1640995200000, // 2022-01-01
+        1672531200000, // 2023-01-01
+        1704067200000  // 2024-01-01
+      ];
+
+      const results: string[] = [];
+      
+      times.forEach(time => {
+        Date.now = jasmine.createSpy('Date.now').and.returnValue(time);
+        const encrypted = DyFM_Crypto.encrypt(timeBasedData, testKey);
+        results.push(encrypted);
+      });
+
+      // All results should be identical
+      const firstResult = results[0];
+      results.forEach(result => {
+        expect(result).toEqual(firstResult);
+      });
+    });
+
+    it('| should maintain consistency across date boundaries', () => {
+      const boundaryTimes = [
+        1609459200000, // 2021-01-01 00:00:00
+        1609459259999, // 2021-01-01 00:00:59
+        1609459260000, // 2021-01-01 00:01:00
+        1609545600000, // 2021-01-02 00:00:00
+        1609632000000, // 2021-01-03 00:00:00
+        1640995200000, // 2022-01-01 00:00:00
+        1672531200000  // 2023-01-01 00:00:00
+      ];
+
+      const results: string[] = [];
+      
+      boundaryTimes.forEach(time => {
+        Date.now = jasmine.createSpy('Date.now').and.returnValue(time);
+        const encrypted = DyFM_Crypto.encrypt(testData, testKey);
+        results.push(encrypted);
+      });
+
+      // All results should be identical
+      const firstResult = results[0];
+      results.forEach(result => {
+        expect(result).toEqual(firstResult);
+      });
+    });
+
+    it('| should handle leap year transitions consistently', () => {
+      const leapYearTimes = [
+        1609459200000, // 2021-01-01 (not leap year)
+        1640995200000, // 2022-01-01 (not leap year)
+        1672531200000, // 2023-01-01 (not leap year)
+        1704067200000, // 2024-01-01 (leap year)
+        1735689600000, // 2025-01-01 (not leap year)
+        1735689600000 + (365 * 24 * 60 * 60 * 1000), // 2025-12-31
+        1735689600000 + (366 * 24 * 60 * 60 * 1000)  // 2026-01-01
+      ];
+
+      const results: string[] = [];
+      
+      leapYearTimes.forEach(time => {
+        Date.now = jasmine.createSpy('Date.now').and.returnValue(time);
+        const encrypted = DyFM_Crypto.encrypt(testData, testKey);
+        results.push(encrypted);
+      });
+
+      // All results should be identical
+      const firstResult = results[0];
+      results.forEach(result => {
+        expect(result).toEqual(firstResult);
+      });
+    });
+
+    it('| should maintain consistency across daylight saving time transitions', () => {
+      // DST transition times (approximate)
+      const dstTimes = [
+        1615708800000, // 2021-03-14 (DST start)
+        1615712400000, // 2021-03-14 01:00 (DST start + 1 hour)
+        1636243200000, // 2021-11-07 (DST end)
+        1636246800000, // 2021-11-07 01:00 (DST end + 1 hour)
+        1648339200000, // 2022-03-13 (DST start)
+        1648342800000, // 2022-03-13 01:00 (DST start + 1 hour)
+        1668816000000, // 2022-11-06 (DST end)
+        1668819600000  // 2022-11-06 01:00 (DST end + 1 hour)
+      ];
+
+      const results: string[] = [];
+      
+      dstTimes.forEach(time => {
+        Date.now = jasmine.createSpy('Date.now').and.returnValue(time);
+        const encrypted = DyFM_Crypto.encrypt(testData, testKey);
+        results.push(encrypted);
+      });
+
+      // All results should be identical
+      const firstResult = results[0];
+      results.forEach(result => {
+        expect(result).toEqual(firstResult);
+      });
+    });
+
+    it('| should handle microsecond precision consistently', () => {
+      const baseTime = 1609459200000;
+      const microsecondOffsets = [
+        0,
+        1,
+        10,
+        100,
+        1000,
+        10000,
+        100000,
+        999999
+      ];
+
+      const results: string[] = [];
+      
+      microsecondOffsets.forEach(offset => {
+        const time = baseTime + offset;
+        Date.now = jasmine.createSpy('Date.now').and.returnValue(time);
+        const encrypted = DyFM_Crypto.encrypt(testData, testKey);
+        results.push(encrypted);
+      });
+
+      // All results should be identical
+      const firstResult = results[0];
+      results.forEach(result => {
+        expect(result).toEqual(firstResult);
+      });
+    });
+
+    it('| should maintain consistency across different Date object states', () => {
+      const testDataWithDates = {
+        date1: new Date('2023-01-01'),
+        date2: new Date('2023-12-31'),
+        date3: new Date(),
+        date4: new Date(0), // Unix epoch
+        date5: new Date(8640000000000000), // Max safe date
+        date6: new Date(-8640000000000000) // Min safe date
+      };
+
+      const results: string[] = [];
+      
+      // Test with different system times
+      const systemTimes = [1609459200000, 1640995200000, 1672531200000];
+      
+      systemTimes.forEach(systemTime => {
+        Date.now = jasmine.createSpy('Date.now').and.returnValue(systemTime);
+        const encrypted = DyFM_Crypto.encrypt(testDataWithDates, testKey);
+        results.push(encrypted);
+      });
+
+      // All results should be identical
+      const firstResult = results[0];
+      results.forEach(result => {
+        expect(result).toEqual(firstResult);
+      });
+    });
+
+    it('| should handle time-based encryption/decryption cycles consistently', () => {
+      const cycles = 10;
+      const results: string[] = [];
+      
+      for (let i = 0; i < cycles; i++) {
+        // Simulate different system times
+        const time = 1609459200000 + (i * 86400000); // Add 1 day each cycle
+        Date.now = jasmine.createSpy('Date.now').and.returnValue(time);
+        
+        const encrypted = DyFM_Crypto.encrypt(testData, testKey);
+        results.push(encrypted);
+      }
+
+      // All results should be identical
+      const firstResult = results[0];
+      results.forEach(result => {
+        expect(result).toEqual(firstResult);
+      });
+    });
+
+    it('| should maintain consistency with real-world time scenarios', () => {
+      const realWorldScenarios = [
+        { name: 'New Year 2021', time: 1609459200000 },
+        { name: 'Leap Day 2020', time: 1583020800000 },
+        { name: 'DST Start 2021', time: 1615708800000 },
+        { name: 'DST End 2021', time: 1636243200000 },
+        { name: 'Midnight UTC', time: 1609459200000 },
+        { name: 'Noon UTC', time: 1609459200000 + (12 * 3600000) },
+        { name: 'End of Day', time: 1609459200000 + (23 * 3600000) + (59 * 60000) + (59 * 1000) }
+      ];
+
+      const results: string[] = [];
+      
+      realWorldScenarios.forEach(scenario => {
+        Date.now = jasmine.createSpy('Date.now').and.returnValue(scenario.time);
+        const encrypted = DyFM_Crypto.encrypt(testData, testKey);
+        results.push(encrypted);
+      });
+
+      // All results should be identical
+      const firstResult = results[0];
+      results.forEach((result, index) => {
+        expect(result).toEqual(firstResult);
+      });
+    });
+  });
+
+  describe('| ERROR HANDLING TESTS - Comprehensive validation', () => {
+    const validKey = 'valid-test-key-123';
+    const validData = { id: 1, name: 'test' };
+
+    describe('| Encryption Error Cases', () => {
+      it('| should throw descriptive error when encrypting undefined data', () => {
+        expect(() => DyFM_Crypto.encrypt(undefined, validKey)).toThrow();
+      });
+
+      it('| should throw descriptive error when encrypting null data', () => {
+        expect(() => DyFM_Crypto.encrypt(null, validKey)).toThrow();
+      });
+
+      it('| should throw descriptive error when encrypting empty string', () => {
+        expect(() => DyFM_Crypto.encrypt('', validKey)).toThrow();
+      });
+
+      it('| should allow empty object for backward compatibility', () => {
+        expect(() => DyFM_Crypto.encrypt({}, validKey)).not.toThrow();
+      });
+
+      it('| should allow empty array for backward compatibility', () => {
+        expect(() => DyFM_Crypto.encrypt([], validKey)).not.toThrow();
+      });
+
+      it('| should throw descriptive error when key is missing', () => {
+        expect(() => DyFM_Crypto.encrypt(validData, undefined as any)).toThrow();
+      });
+
+      it('| should throw descriptive error when key is null', () => {
+        expect(() => DyFM_Crypto.encrypt(validData, null as any)).toThrow();
+      });
+
+      it('| should throw descriptive error when key is not a string', () => {
+        expect(() => DyFM_Crypto.encrypt(validData, 123 as any)).toThrow();
+      });
+
+      it('| should throw descriptive error when key is empty string', () => {
+        expect(() => DyFM_Crypto.encrypt(validData, '')).toThrow();
+      });
+
+      it('| should throw descriptive error when key is only whitespace', () => {
+        expect(() => DyFM_Crypto.encrypt(validData, '   ')).toThrow();
+      });
+
+      it('| should warn about short keys but still work', () => {
+        // This test just ensures encryption works with short keys
+        // Note: Warning is shown in console but spy might not catch it in test environment
+        expect(() => DyFM_Crypto.encrypt(validData, 'short')).not.toThrow();
+      });
+    });
+
+    describe('| Decryption Error Cases', () => {
+      it('| should throw descriptive error when decrypting undefined data', () => {
+        expect(() => DyFM_Crypto.decrypt(undefined as any, validKey)).toThrow();
+      });
+
+      it('| should throw descriptive error when decrypting null data', () => {
+        expect(() => DyFM_Crypto.decrypt(null as any, validKey)).toThrow();
+      });
+
+      it('| should throw descriptive error when decrypting non-string data', () => {
+        expect(() => DyFM_Crypto.decrypt(123 as any, validKey)).toThrow();
+      });
+
+      it('| should throw descriptive error when decrypting empty string', () => {
+        expect(() => DyFM_Crypto.decrypt('', validKey)).toThrow();
+      });
+
+      it('| should throw descriptive error when decrypting too short data', () => {
+        expect(() => DyFM_Crypto.decrypt('short', validKey)).toThrow();
+      });
+
+      it('| should throw descriptive error when decrypting invalid format', () => {
+        expect(() => DyFM_Crypto.decrypt('invalid!@#format', validKey)).toThrow();
+      });
+
+      it('| should throw descriptive error when key is missing for decryption', () => {
+        const encrypted = DyFM_Crypto.encrypt(validData, validKey);
+        expect(() => DyFM_Crypto.decrypt(encrypted, undefined as any)).toThrow();
+      });
+
+      it('| should throw descriptive error when key is wrong type for decryption', () => {
+        const encrypted = DyFM_Crypto.encrypt(validData, validKey);
+        expect(() => DyFM_Crypto.decrypt(encrypted, 123 as any)).toThrow();
+      });
+
+      it('| should throw descriptive error when key is empty for decryption', () => {
+        const encrypted = DyFM_Crypto.encrypt(validData, validKey);
+        expect(() => DyFM_Crypto.decrypt(encrypted, '')).toThrow();
+      });
+
+      it('| should handle decryption with proper key validation', () => {
+        // Test that decryption works with valid key
+        const encrypted = DyFM_Crypto.encrypt(validData, validKey);
+        expect(() => DyFM_Crypto.decrypt(encrypted, validKey)).not.toThrow();
+      });
+    });
+
+    describe('| Decryption Failure Scenarios', () => {
+      it('| should throw descriptive error when decrypting with wrong key', () => {
+        const encrypted = DyFM_Crypto.encrypt(validData, validKey);
+        expect(() => DyFM_Crypto.decrypt(encrypted, 'wrong-key-123')).toThrow();
+      });
+
+      it('| should throw descriptive error when decrypting corrupted data', () => {
+        const encrypted = DyFM_Crypto.encrypt(validData, validKey);
+        const corrupted = encrypted.substring(0, encrypted.length - 10); // Remove last 10 characters
+        expect(() => DyFM_Crypto.decrypt(corrupted, validKey)).toThrow();
+      });
+
+      it('| should throw descriptive error when decrypting invalid base64', () => {
+        expect(() => DyFM_Crypto.decrypt('invalid-base64!@#', validKey)).toThrow();
+      });
+
+      it('| should throw descriptive error when decrypting completely wrong data', () => {
+        expect(() => DyFM_Crypto.decrypt('this-is-not-encrypted-data', validKey)).toThrow();
+      });
+    });
+
+    describe('| Edge Case Validations', () => {
+      it('| should allow valid data with minimum key length', () => {
+        const shortKey = '12345678'; // 8 characters minimum
+        const encrypted = DyFM_Crypto.encrypt(validData, shortKey);
+        const decrypted = DyFM_Crypto.decrypt(encrypted, shortKey);
+        expect(decrypted).toEqual(validData);
+      });
+
+      it('| should allow valid data with whitespace in key', () => {
+        const keyWithSpaces = '  valid-key-123  ';
+        const encrypted = DyFM_Crypto.encrypt(validData, keyWithSpaces);
+        const decrypted = DyFM_Crypto.decrypt(encrypted, keyWithSpaces);
+        expect(decrypted).toEqual(validData);
+      });
+
+      it('| should handle special characters in data', () => {
+        const specialData = { 
+          special: '!@#$%^&*()_+-=[]{}|;:,.<>?',
+          unicode: '世界你好',
+          emoji: '🚀💻🔐'
+        };
+        const encrypted = DyFM_Crypto.encrypt(specialData, validKey);
+        const decrypted = DyFM_Crypto.decrypt(encrypted, validKey);
+        expect(decrypted).toEqual(specialData);
+      });
+
+      it('| should handle very long data', () => {
+        const longData = {
+          text: 'A'.repeat(10000),
+          array: Array(1000).fill(0).map((_, i) => i),
+          nested: {
+            level1: { level2: { level3: { data: 'deep nested data' } } }
+          }
+        };
+        const encrypted = DyFM_Crypto.encrypt(longData, validKey);
+        const decrypted = DyFM_Crypto.decrypt(encrypted, validKey);
+        expect(decrypted).toEqual(longData);
+      });
+    });
+
+    describe('| Error Code Validation', () => {
+      it('| should have specific error codes for different failure types', () => {
+        try {
+          DyFM_Crypto.encrypt(undefined, validKey);
+          fail('Should have thrown an error');
+        } catch (error: any) {
+          expect(error._errorCode).toBe('DyFM-CRY-DATA-UNDEFINED');
+        }
+
+        try {
+          DyFM_Crypto.encrypt(validData, '');
+          fail('Should have thrown an error');
+        } catch (error: any) {
+          expect(error._errorCode).toBe('DyFM-CRY-KEY-MISSING');
+        }
+
+        try {
+          DyFM_Crypto.decrypt('', validKey);
+          fail('Should have thrown an error');
+        } catch (error: any) {
+          expect(error._errorCode).toBe('DyFM-CRY-ENCRYPTED-EMPTY');
+        }
+      });
+    });
+  });
 });