@futdevpro/fsm-dynamo 1.15.21 → 1.15.22

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

@@ -1,513 +1,513 @@
-import { DyFM_Crypto } from './crypto.util';
-
-describe('| DyFM_Crypto basic tests', () => {
-  const testKey = 'test-secret-key-123';
-  const testData = { id: 1, name: 'test' };
-
-  describe('| encrypt', () => {
-    it('| should successfully encrypt data', () => {
-      const encrypted = DyFM_Crypto.encrypt(testData, testKey);
-      
-      expect(encrypted).toBeDefined();
-      expect(typeof encrypted).toBe('string');
-      expect(encrypted).toMatch(/^[A-Za-z0-9\-_]+$/);
-    });
-
-    it('| should encrypt different data with different results', () => {
-      const data1 = { id: 1 };
-      const data2 = { id: 2 };
-
-      const encrypted1 = DyFM_Crypto.encrypt(data1, testKey);
-      const encrypted2 = DyFM_Crypto.encrypt(data2, testKey);
-
-      expect(encrypted1).not.toEqual(encrypted2);
-    });
-
-    it('| should throw DyFM_Error when encryption fails', () => {
-      // @ts-ignore - Testing invalid input
-      expect(() => DyFM_Crypto.encrypt(undefined, testKey)).toThrow();
-    });
-
-    it('| should handle complex objects', () => {
-      const complexData = {
-        id: 1,
-        name: 'test',
-        nested: {
-          value: 'nested-value',
-          array: [1, 2, 3]
-        }
-      };
-
-      const encrypted = DyFM_Crypto.encrypt(complexData, testKey);
-      const decrypted = DyFM_Crypto.decrypt(encrypted, testKey);
-
-      expect(decrypted).toEqual(complexData);
-    });
-
-    it('| should get the same result with the same input', () => {
-      const complexData = {
-        id: 2,
-        name: 'test',
-        nested: {
-          value: 'nested-value',
-          array: [1, 2, 3]
-        }
-      };
-      const expectedResult = JSON.stringify(complexData);
-
-      const encrypted = DyFM_Crypto.encrypt(complexData, testKey);
-      const decrypted = DyFM_Crypto.decrypt(encrypted, testKey);
-
-      const result = JSON.stringify(decrypted);
-      expect(result).toBe(expectedResult);
-    });
-
-    it('| should not effect the original object', () => {
-      const complexData = {
-        id: 1,
-        name: 'test',
-        nested: { value: 'nested-value', array: [1, 2, 3] }
-      };
-      const originalData = JSON.stringify(complexData);
-
-      const encrypted = DyFM_Crypto.encrypt(complexData, testKey);
-      const decrypted = DyFM_Crypto.decrypt(encrypted, testKey);
-
-      const result = JSON.stringify(decrypted);
-      expect(result).toBe(originalData);
-    });
-
-    it('| should handle arrays', () => {
-      const arrayData = [1, 'test', { nested: true }];
-      const encrypted = DyFM_Crypto.encrypt(arrayData, testKey);
-      const decrypted = DyFM_Crypto.decrypt(encrypted, testKey);
-
-      expect(decrypted).toEqual(arrayData);
-    });
-
-    it('| should handle primitive values', () => {
-      const stringData = 'test string';
-      const numberData = 42;
-      const booleanData = true;
-
-      const encryptedString = DyFM_Crypto.encrypt(stringData, testKey);
-      const encryptedNumber = DyFM_Crypto.encrypt(numberData, testKey);
-      const encryptedBoolean = DyFM_Crypto.encrypt(booleanData, testKey);
-
-      expect(DyFM_Crypto.decrypt(encryptedString, testKey)).toBe(stringData);
-      expect(DyFM_Crypto.decrypt(encryptedNumber, testKey)).toBe(numberData);
-      expect(DyFM_Crypto.decrypt(encryptedBoolean, testKey)).toBe(booleanData);
-    });
-  });
-
-  describe('| decrypt', () => {
-    it('| should successfully decrypt encrypted data', () => {
-      const encrypted = DyFM_Crypto.encrypt(testData, testKey);
-      const decrypted = DyFM_Crypto.decrypt(encrypted, testKey);
-
-      expect(decrypted).toEqual(testData);
-    });
-
-    it('| should throw DyFM_Error when decryption fails', () => {
-      expect(() => DyFM_Crypto.decrypt('invalid-encrypted-data', testKey)).toThrow();
-    });
-
-    it('| should throw DyFM_Error when using wrong key', () => {
-      const encrypted = DyFM_Crypto.encrypt(testData, testKey);
-      expect(() => DyFM_Crypto.decrypt(encrypted, 'wrong-key')).toThrow();
-    });
-
-    it('| should throw DyFM_Error when encrypted data is modified', () => {
-      const encrypted = DyFM_Crypto.encrypt(testData, testKey);
-      const modified = encrypted.slice(0, -1) + 'A';
-      expect(() => DyFM_Crypto.decrypt(modified, testKey)).toThrow();
-    });
-  });
-
-  describe('| URL-safe encryption', () => {
-    it('| should produce URL-safe strings', () => {
-      const encrypted = DyFM_Crypto.encrypt(testData, testKey);
-      expect(encrypted).toMatch(/^[A-Za-z0-9\-_]+$/);
-    });
-
-    it('| should work in HTTP headers', () => {
-      const encrypted = DyFM_Crypto.encrypt(testData, testKey);
-      const header = `Bearer ${encrypted}`;
-      const extracted = header.split(' ')[1];
-      const decrypted = DyFM_Crypto.decrypt(extracted, testKey);
-      expect(decrypted).toEqual(testData);
-    });
-
-    it('| should work in URLs', () => {
-      const encrypted = DyFM_Crypto.encrypt(testData, testKey);
-      const url = `https://example.com/api?token=${encrypted}`;
-      const params = new URLSearchParams(url.split('?')[1]);
-      const extracted = params.get('token');
-      const decrypted = DyFM_Crypto.decrypt(extracted!, testKey);
-      expect(decrypted).toEqual(testData);
-    });
-  });
-
-  describe('| LONG-TERM STABILITY TESTS - Cross-platform compatibility', () => {
-    describe('| Deterministic encryption consistency', () => {
-      it('| should produce identical encrypted output for identical input across multiple calls', () => {
-        const testData = { id: 1, name: 'test', timestamp: '2024-01-01T00:00:00Z' };
-        const key = 'stable-test-key-123';
-
-        // Multiple encryption calls should produce identical results
-        const encrypted1 = DyFM_Crypto.encrypt(testData, key);
-        const encrypted2 = DyFM_Crypto.encrypt(testData, key);
-        const encrypted3 = DyFM_Crypto.encrypt(testData, key);
-
-        expect(encrypted1).toBe(encrypted2);
-        expect(encrypted2).toBe(encrypted3);
-        expect(encrypted1).toBe(encrypted3);
-
-        // All should decrypt to the same data
-        const decrypted1 = DyFM_Crypto.decrypt(encrypted1, key);
-        const decrypted2 = DyFM_Crypto.decrypt(encrypted2, key);
-        const decrypted3 = DyFM_Crypto.decrypt(encrypted3, key);
-
-        expect(decrypted1).toEqual(decrypted2);
-        expect(decrypted2).toEqual(decrypted3);
-        expect(decrypted1).toEqual(testData);
-      });
-
-      it('| should maintain consistency with different data types and structures', () => {
-        const testCases = [
-          { data: { id: 1, name: 'simple' }, key: 'key1' },
-          { data: 'plain string', key: 'key2' },
-          { data: [1, 2, 3, 'array'], key: 'key3' },
-          { data: { nested: { deep: { value: true } } }, key: 'key4' },
-          { data: { empty: {}, null: null }, key: 'key5' } // Removed undefined as it gets filtered out
-        ];
-
-        testCases.forEach(({ data, key }) => {
-          const encrypted1 = DyFM_Crypto.encrypt(data, key);
-          const encrypted2 = DyFM_Crypto.encrypt(data, key);
-          expect(encrypted1).toBe(encrypted2);
-          
-          const decrypted = DyFM_Crypto.decrypt(encrypted1, key);
-          expect(decrypted).toEqual(data);
-        });
-      });
-
-      it('| should handle edge cases consistently', () => {
-        const edgeCases = [
-          { 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: 'non-empty' }, key: 'mixed-edge-key' }
-        ];
-
-        edgeCases.forEach(({ data, key }) => {
-          const encrypted1 = DyFM_Crypto.encrypt(data, key);
-          const encrypted2 = DyFM_Crypto.encrypt(data, key);
-          expect(encrypted1).toBe(encrypted2);
-          
-          const decrypted = DyFM_Crypto.decrypt(encrypted1, key);
-          expect(decrypted).toEqual(data);
-        });
-      });
-    });
-
-    describe('| Cross-version compatibility simulation', () => {
-      it('| should handle data encrypted with different configurations consistently', () => {
-        const testData = { id: 1, name: 'config-test' };
-        const key = 'config-test-key';
-
-        // Test with default config
-        const defaultEncrypted = DyFM_Crypto.encrypt(testData, key);
-        const defaultDecrypted = DyFM_Crypto.decrypt(defaultEncrypted, key);
-        expect(defaultDecrypted).toEqual(testData);
-
-        // Test with custom config
-        const customConfig = { keyIterations: 500, keySize: 6 };
-        const customEncrypted = DyFM_Crypto.encrypt(testData, key, customConfig);
-        const customDecrypted = DyFM_Crypto.decrypt(customEncrypted, key, customConfig);
-        expect(customDecrypted).toEqual(testData);
-
-        // Test that different configs produce different encrypted results
-        expect(defaultEncrypted).not.toBe(customEncrypted);
-      });
-
-      it('| should maintain backward compatibility with existing encrypted data', () => {
-        // Simulate data that was encrypted with previous version
-        const legacyData = { id: 1, name: 'legacy-test', version: '1.0' };
-        const key = 'legacy-key';
-
-        // Encrypt with current implementation
-        const encrypted = DyFM_Crypto.encrypt(legacyData, key);
-        
-        // Simulate system restart/reload
-        const decrypted = DyFM_Crypto.decrypt(encrypted, key);
-        expect(decrypted).toEqual(legacyData);
-
-        // Re-encrypt should produce same result
-        const reEncrypted = DyFM_Crypto.encrypt(decrypted, key);
-        expect(reEncrypted).toBe(encrypted);
-      });
-    });
-
-    describe('| Platform independence tests', () => {
-      it('| should handle different character encodings consistently', () => {
-        const unicodeData = {
-          hungarian: 'árvíztűrő tükörfúrógép',
-          chinese: '你好世界',
-          emoji: '🚀💻🔒',
-          special: '!@#$%^&*()_+-=[]{}|;:,.<>?'
-        };
-        const key = 'unicode-test-key';
-
-        const encrypted = DyFM_Crypto.encrypt(unicodeData, key);
-        const decrypted = DyFM_Crypto.decrypt(encrypted, key);
-        expect(decrypted).toEqual(unicodeData);
-
-        // Multiple encryptions should be identical
-        const encrypted2 = DyFM_Crypto.encrypt(unicodeData, key);
-        expect(encrypted).toBe(encrypted2);
-      });
-
-      it('| should handle large data objects consistently', () => {
-        // Create a large object with many properties
-        const largeData: any = { id: 1 };
-        for (let i = 0; i < 100; i++) {
-          largeData[`prop${i}`] = `value${i}`;
-        }
-        const key = 'large-data-key';
-
-        const encrypted1 = DyFM_Crypto.encrypt(largeData, key);
-        const encrypted2 = DyFM_Crypto.encrypt(largeData, key);
-        expect(encrypted1).toBe(encrypted2);
-
-        const decrypted = DyFM_Crypto.decrypt(encrypted1, key);
-        expect(decrypted).toEqual(largeData);
-      });
-
-      it('| should handle nested circular references gracefully', () => {
-        const circularData: any = { id: 1, name: 'circular' };
-        circularData.self = circularData;
-        const key = 'circular-key';
-
-        // Should handle circular references without crashing
-        expect(() => {
-          const encrypted = DyFM_Crypto.encrypt(circularData, key);
-          // Note: JSON.stringify will fail on circular refs, so this test ensures graceful handling
-        }).toThrow(); // Expected to throw due to circular reference
-      });
-    });
-
-    describe('| Time-based stability tests', () => {
-      it('| should maintain consistency across time-based operations', () => {
-        const timeData = {
-          timestamp: new Date().toISOString(),
-          id: 1,
-          name: 'time-test'
-        };
-        const key = 'time-test-key';
-
-        // Encrypt same data multiple times
-        const encrypted1 = DyFM_Crypto.encrypt(timeData, key);
-        
-        // Simulate time passing
-        setTimeout(() => {
-          const encrypted2 = DyFM_Crypto.encrypt(timeData, key);
-          expect(encrypted1).toBe(encrypted2);
-        }, 100);
-      });
-
-      it('| should handle date objects consistently', () => {
-        const dateData = {
-          created: new Date('2024-01-01T00:00:00Z'),
-          updated: new Date('2024-12-31T23:59:59Z'),
-          id: 1
-        };
-        const key = 'date-test-key';
-
-        const encrypted1 = DyFM_Crypto.encrypt(dateData, key);
-        const encrypted2 = DyFM_Crypto.encrypt(dateData, key);
-        expect(encrypted1).toBe(encrypted2);
-
-        const decrypted = DyFM_Crypto.decrypt(encrypted1, key) as any;
-        // Compare ISO strings since JSON serialization converts dates to strings
-        expect(decrypted.created).toEqual(dateData.created.toISOString());
-        expect(decrypted.updated).toEqual(dateData.updated.toISOString());
-        expect(decrypted.id).toBe(dateData.id);
-      });
-    });
-
-    describe('| Memory and performance stability', () => {
-      it('| should handle multiple encryption/decryption cycles without memory leaks', () => {
-        const testData = { id: 1, name: 'memory-test' };
-        const key = 'memory-test-key';
-
-        // Perform many encryption/decryption cycles
-        for (let i = 0; i < 1000; i++) {
-          const encrypted = DyFM_Crypto.encrypt(testData, key);
-          const decrypted = DyFM_Crypto.decrypt(encrypted, key);
-          expect(decrypted).toEqual(testData);
-        }
-      });
-
-      it('| should maintain consistent performance across multiple operations', () => {
-        const testData = { id: 1, name: 'performance-test' };
-        const key = 'performance-test-key';
-
-        const startTime = Date.now();
-        
-        // Perform multiple operations
-        for (let i = 0; i < 100; i++) {
-          const encrypted = DyFM_Crypto.encrypt(testData, key);
-          const decrypted = DyFM_Crypto.decrypt(encrypted, key);
-          expect(decrypted).toEqual(testData);
-        }
-
-        const endTime = Date.now();
-        const duration = endTime - startTime;
-        
-        // Should complete within reasonable time (adjust threshold as needed)
-        expect(duration).toBeLessThan(6000); // 6 seconds max
-      });
-    });
-  });
-
-  describe('| URL-safe base64 transmission edge cases', () => {
-    it('| should handle encrypted data that loses padding during URL transmission', () => {
-      const encrypted = DyFM_Crypto.encrypt(testData, testKey);
-      // Simulate padding loss during URL transmission
-      // Encrypted data already has no padding (removed in encrypt), so this tests normal behavior
-      expect(() => DyFM_Crypto.decrypt(encrypted, testKey)).not.toThrow();
-      const decrypted = DyFM_Crypto.decrypt(encrypted, testKey);
-      expect(decrypted).toEqual(testData);
-    });
-
-    it('| should handle encrypted data with 0 padding characters (normal case)', () => {
-      const encrypted = DyFM_Crypto.encrypt(testData, testKey);
-      // Encrypted data has no padding (removed by .replace(/=+$/, ''))
-      expect(encrypted).not.toContain('=');
-      expect(() => DyFM_Crypto.decrypt(encrypted, testKey)).not.toThrow();
-      const decrypted = DyFM_Crypto.decrypt(encrypted, testKey);
-      expect(decrypted).toEqual(testData);
-    });
-
-    it('| should handle encrypted data that would need 1 padding character', () => {
-      // Create a scenario where base64 would need 1 padding char
-      // This is tested by encrypting and verifying it works without padding
-      const encrypted = DyFM_Crypto.encrypt(testData, testKey);
-      // If the encrypted string length % 4 === 3, it would need 1 padding char
-      // But since padding is removed, we verify it still works
-      expect(() => DyFM_Crypto.decrypt(encrypted, testKey)).not.toThrow();
-    });
-
-    it('| should handle encrypted data that would need 2 padding characters', () => {
-      // Create a scenario where base64 would need 2 padding chars
-      const encrypted = DyFM_Crypto.encrypt(testData, testKey);
-      // If the encrypted string length % 4 === 2, it would need 2 padding chars
-      // Verify it works without explicit padding
-      expect(() => DyFM_Crypto.decrypt(encrypted, testKey)).not.toThrow();
-    });
-
-    it('| should handle encrypted data that would need 3 padding characters', () => {
-      // Create a scenario where base64 would need 3 padding chars
-      const encrypted = DyFM_Crypto.encrypt(testData, testKey);
-      // If the encrypted string length % 4 === 1, it would need 3 padding chars
-      // Verify it works without explicit padding
-      expect(() => DyFM_Crypto.decrypt(encrypted, testKey)).not.toThrow();
-    });
-
-    it('| should handle base64 strings that are valid but too short after parsing', () => {
-      // Create a valid URL-safe base64 string that's too short
-      const validButShort = 'ABCDEFGHIJKLMNOPQRSTUVWXY'; // 25 chars, valid format but too short
-      expect(() => DyFM_Crypto.decrypt(validButShort, testKey)).toThrow();
-    });
-
-    it('| should handle round-trip encryption/decryption with padding edge cases', () => {
-      // Test that encryption/decryption works correctly even when padding is removed
-      const testCases = [
-        { id: 1, name: 'test' },
-        { id: 2, data: 'short' },
-        { id: 3, data: 'A'.repeat(100) }, // Longer data
-        { id: 4, nested: { value: true } }
-      ];
-
-      testCases.forEach(testCase => {
-        const encrypted = DyFM_Crypto.encrypt(testCase, testKey);
-        // Verify no padding in encrypted string
-        expect(encrypted).not.toContain('=');
-        // Verify round-trip works
-        const decrypted = DyFM_Crypto.decrypt(encrypted, testKey);
-        expect(decrypted).toEqual(testCase);
-      });
-    });
-
-    it('| should handle URL-safe base64 conversion correctly', () => {
-      const encrypted = DyFM_Crypto.encrypt(testData, testKey);
-      // Verify it's URL-safe (no +, /, or =)
-      expect(encrypted).not.toContain('+');
-      expect(encrypted).not.toContain('/');
-      expect(encrypted).not.toContain('=');
-      // Verify it can be decrypted
-      expect(() => DyFM_Crypto.decrypt(encrypted, testKey)).not.toThrow();
-    });
-
-    it('| should handle base64 strings with various padding scenarios in transmission', () => {
-      const encrypted = DyFM_Crypto.encrypt(testData, testKey);
-      
-      // Simulate different padding scenarios that might occur during transmission
-      // Even though encrypted data has no padding, test that decryption handles it
-      const scenarios = [
-        encrypted, // No padding (normal)
-        encrypted + '=', // 1 padding char added
-        encrypted + '==', // 2 padding chars added
-        encrypted + '===' // 3 padding chars added
-      ];
-
-      // The first one should work (no padding)
-      expect(() => DyFM_Crypto.decrypt(scenarios[0], testKey)).not.toThrow();
-      
-      // Others might work or fail depending on base64 parsing
-      scenarios.slice(1).forEach((scenario, index) => {
-        // These might work if CryptoJS handles padding, or fail if data is corrupted
-        try {
-          const decrypted = DyFM_Crypto.decrypt(scenario, testKey);
-          expect(decrypted).toEqual(testData);
-        } catch {
-          // If it fails, that's also acceptable as extra padding shouldn't be there
-          expect(() => DyFM_Crypto.decrypt(scenario, testKey)).toThrow();
-        }
-      });
-    });
-
-    it('| should handle URL encoding/decoding edge cases', () => {
-      const encrypted = DyFM_Crypto.encrypt(testData, testKey);
-      
-      // Simulate URL encoding (though encrypted data should already be URL-safe)
-      // Test that the encrypted string works in URL contexts
-      const urlEncoded = encodeURIComponent(encrypted);
-      const urlDecoded = decodeURIComponent(urlEncoded);
-      
-      // Should be able to decrypt after URL encoding/decoding
-      expect(() => DyFM_Crypto.decrypt(urlDecoded, testKey)).not.toThrow();
-      const decrypted = DyFM_Crypto.decrypt(urlDecoded, testKey);
-      expect(decrypted).toEqual(testData);
-    });
-
-    it('| should handle base64 strings that are valid format but truncated', () => {
-      const encrypted = DyFM_Crypto.encrypt(testData, testKey);
-      // Truncate to various lengths that are still valid base64 format
-      const truncationPoints = [
-        Math.floor(encrypted.length * 0.5),
-        Math.floor(encrypted.length * 0.75),
-        encrypted.length - 5,
-        encrypted.length - 10
-      ];
-
-      truncationPoints.forEach(point => {
-        const truncated = encrypted.substring(0, point);
-        // Should throw error for truncated data
-        expect(() => DyFM_Crypto.decrypt(truncated, testKey)).toThrow();
-      });
-    });
-  });
-
+import { DyFM_Crypto } from './crypto.util';
+
+describe('| DyFM_Crypto basic tests', () => {
+  const testKey = 'test-secret-key-123';
+  const testData = { id: 1, name: 'test' };
+
+  describe('| encrypt', () => {
+    it('| should successfully encrypt data', () => {
+      const encrypted = DyFM_Crypto.encrypt(testData, testKey);
+      
+      expect(encrypted).toBeDefined();
+      expect(typeof encrypted).toBe('string');
+      expect(encrypted).toMatch(/^[A-Za-z0-9\-_]+$/);
+    });
+
+    it('| should encrypt different data with different results', () => {
+      const data1 = { id: 1 };
+      const data2 = { id: 2 };
+
+      const encrypted1 = DyFM_Crypto.encrypt(data1, testKey);
+      const encrypted2 = DyFM_Crypto.encrypt(data2, testKey);
+
+      expect(encrypted1).not.toEqual(encrypted2);
+    });
+
+    it('| should throw DyFM_Error when encryption fails', () => {
+      // @ts-ignore - Testing invalid input
+      expect(() => DyFM_Crypto.encrypt(undefined, testKey)).toThrow();
+    });
+
+    it('| should handle complex objects', () => {
+      const complexData = {
+        id: 1,
+        name: 'test',
+        nested: {
+          value: 'nested-value',
+          array: [1, 2, 3]
+        }
+      };
+
+      const encrypted = DyFM_Crypto.encrypt(complexData, testKey);
+      const decrypted = DyFM_Crypto.decrypt(encrypted, testKey);
+
+      expect(decrypted).toEqual(complexData);
+    });
+
+    it('| should get the same result with the same input', () => {
+      const complexData = {
+        id: 2,
+        name: 'test',
+        nested: {
+          value: 'nested-value',
+          array: [1, 2, 3]
+        }
+      };
+      const expectedResult = JSON.stringify(complexData);
+
+      const encrypted = DyFM_Crypto.encrypt(complexData, testKey);
+      const decrypted = DyFM_Crypto.decrypt(encrypted, testKey);
+
+      const result = JSON.stringify(decrypted);
+      expect(result).toBe(expectedResult);
+    });
+
+    it('| should not effect the original object', () => {
+      const complexData = {
+        id: 1,
+        name: 'test',
+        nested: { value: 'nested-value', array: [1, 2, 3] }
+      };
+      const originalData = JSON.stringify(complexData);
+
+      const encrypted = DyFM_Crypto.encrypt(complexData, testKey);
+      const decrypted = DyFM_Crypto.decrypt(encrypted, testKey);
+
+      const result = JSON.stringify(decrypted);
+      expect(result).toBe(originalData);
+    });
+
+    it('| should handle arrays', () => {
+      const arrayData = [1, 'test', { nested: true }];
+      const encrypted = DyFM_Crypto.encrypt(arrayData, testKey);
+      const decrypted = DyFM_Crypto.decrypt(encrypted, testKey);
+
+      expect(decrypted).toEqual(arrayData);
+    });
+
+    it('| should handle primitive values', () => {
+      const stringData = 'test string';
+      const numberData = 42;
+      const booleanData = true;
+
+      const encryptedString = DyFM_Crypto.encrypt(stringData, testKey);
+      const encryptedNumber = DyFM_Crypto.encrypt(numberData, testKey);
+      const encryptedBoolean = DyFM_Crypto.encrypt(booleanData, testKey);
+
+      expect(DyFM_Crypto.decrypt(encryptedString, testKey)).toBe(stringData);
+      expect(DyFM_Crypto.decrypt(encryptedNumber, testKey)).toBe(numberData);
+      expect(DyFM_Crypto.decrypt(encryptedBoolean, testKey)).toBe(booleanData);
+    });
+  });
+
+  describe('| decrypt', () => {
+    it('| should successfully decrypt encrypted data', () => {
+      const encrypted = DyFM_Crypto.encrypt(testData, testKey);
+      const decrypted = DyFM_Crypto.decrypt(encrypted, testKey);
+
+      expect(decrypted).toEqual(testData);
+    });
+
+    it('| should throw DyFM_Error when decryption fails', () => {
+      expect(() => DyFM_Crypto.decrypt('invalid-encrypted-data', testKey)).toThrow();
+    });
+
+    it('| should throw DyFM_Error when using wrong key', () => {
+      const encrypted = DyFM_Crypto.encrypt(testData, testKey);
+      expect(() => DyFM_Crypto.decrypt(encrypted, 'wrong-key')).toThrow();
+    });
+
+    it('| should throw DyFM_Error when encrypted data is modified', () => {
+      const encrypted = DyFM_Crypto.encrypt(testData, testKey);
+      const modified = encrypted.slice(0, -1) + 'A';
+      expect(() => DyFM_Crypto.decrypt(modified, testKey)).toThrow();
+    });
+  });
+
+  describe('| URL-safe encryption', () => {
+    it('| should produce URL-safe strings', () => {
+      const encrypted = DyFM_Crypto.encrypt(testData, testKey);
+      expect(encrypted).toMatch(/^[A-Za-z0-9\-_]+$/);
+    });
+
+    it('| should work in HTTP headers', () => {
+      const encrypted = DyFM_Crypto.encrypt(testData, testKey);
+      const header = `Bearer ${encrypted}`;
+      const extracted = header.split(' ')[1];
+      const decrypted = DyFM_Crypto.decrypt(extracted, testKey);
+      expect(decrypted).toEqual(testData);
+    });
+
+    it('| should work in URLs', () => {
+      const encrypted = DyFM_Crypto.encrypt(testData, testKey);
+      const url = `https://example.com/api?token=${encrypted}`;
+      const params = new URLSearchParams(url.split('?')[1]);
+      const extracted = params.get('token');
+      const decrypted = DyFM_Crypto.decrypt(extracted!, testKey);
+      expect(decrypted).toEqual(testData);
+    });
+  });
+
+  describe('| LONG-TERM STABILITY TESTS - Cross-platform compatibility', () => {
+    describe('| Deterministic encryption consistency', () => {
+      it('| should produce identical encrypted output for identical input across multiple calls', () => {
+        const testData = { id: 1, name: 'test', timestamp: '2024-01-01T00:00:00Z' };
+        const key = 'stable-test-key-123';
+
+        // Multiple encryption calls should produce identical results
+        const encrypted1 = DyFM_Crypto.encrypt(testData, key);
+        const encrypted2 = DyFM_Crypto.encrypt(testData, key);
+        const encrypted3 = DyFM_Crypto.encrypt(testData, key);
+
+        expect(encrypted1).toBe(encrypted2);
+        expect(encrypted2).toBe(encrypted3);
+        expect(encrypted1).toBe(encrypted3);
+
+        // All should decrypt to the same data
+        const decrypted1 = DyFM_Crypto.decrypt(encrypted1, key);
+        const decrypted2 = DyFM_Crypto.decrypt(encrypted2, key);
+        const decrypted3 = DyFM_Crypto.decrypt(encrypted3, key);
+
+        expect(decrypted1).toEqual(decrypted2);
+        expect(decrypted2).toEqual(decrypted3);
+        expect(decrypted1).toEqual(testData);
+      });
+
+      it('| should maintain consistency with different data types and structures', () => {
+        const testCases = [
+          { data: { id: 1, name: 'simple' }, key: 'key1' },
+          { data: 'plain string', key: 'key2' },
+          { data: [1, 2, 3, 'array'], key: 'key3' },
+          { data: { nested: { deep: { value: true } } }, key: 'key4' },
+          { data: { empty: {}, null: null }, key: 'key5' } // Removed undefined as it gets filtered out
+        ];
+
+        testCases.forEach(({ data, key }) => {
+          const encrypted1 = DyFM_Crypto.encrypt(data, key);
+          const encrypted2 = DyFM_Crypto.encrypt(data, key);
+          expect(encrypted1).toBe(encrypted2);
+          
+          const decrypted = DyFM_Crypto.decrypt(encrypted1, key);
+          expect(decrypted).toEqual(data);
+        });
+      });
+
+      it('| should handle edge cases consistently', () => {
+        const edgeCases = [
+          { 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: 'non-empty' }, key: 'mixed-edge-key' }
+        ];
+
+        edgeCases.forEach(({ data, key }) => {
+          const encrypted1 = DyFM_Crypto.encrypt(data, key);
+          const encrypted2 = DyFM_Crypto.encrypt(data, key);
+          expect(encrypted1).toBe(encrypted2);
+          
+          const decrypted = DyFM_Crypto.decrypt(encrypted1, key);
+          expect(decrypted).toEqual(data);
+        });
+      });
+    });
+
+    describe('| Cross-version compatibility simulation', () => {
+      it('| should handle data encrypted with different configurations consistently', () => {
+        const testData = { id: 1, name: 'config-test' };
+        const key = 'config-test-key';
+
+        // Test with default config
+        const defaultEncrypted = DyFM_Crypto.encrypt(testData, key);
+        const defaultDecrypted = DyFM_Crypto.decrypt(defaultEncrypted, key);
+        expect(defaultDecrypted).toEqual(testData);
+
+        // Test with custom config
+        const customConfig = { keyIterations: 500, keySize: 6 };
+        const customEncrypted = DyFM_Crypto.encrypt(testData, key, customConfig);
+        const customDecrypted = DyFM_Crypto.decrypt(customEncrypted, key, customConfig);
+        expect(customDecrypted).toEqual(testData);
+
+        // Test that different configs produce different encrypted results
+        expect(defaultEncrypted).not.toBe(customEncrypted);
+      });
+
+      it('| should maintain backward compatibility with existing encrypted data', () => {
+        // Simulate data that was encrypted with previous version
+        const legacyData = { id: 1, name: 'legacy-test', version: '1.0' };
+        const key = 'legacy-key';
+
+        // Encrypt with current implementation
+        const encrypted = DyFM_Crypto.encrypt(legacyData, key);
+        
+        // Simulate system restart/reload
+        const decrypted = DyFM_Crypto.decrypt(encrypted, key);
+        expect(decrypted).toEqual(legacyData);
+
+        // Re-encrypt should produce same result
+        const reEncrypted = DyFM_Crypto.encrypt(decrypted, key);
+        expect(reEncrypted).toBe(encrypted);
+      });
+    });
+
+    describe('| Platform independence tests', () => {
+      it('| should handle different character encodings consistently', () => {
+        const unicodeData = {
+          hungarian: 'árvíztűrő tükörfúrógép',
+          chinese: '你好世界',
+          emoji: '🚀💻🔒',
+          special: '!@#$%^&*()_+-=[]{}|;:,.<>?'
+        };
+        const key = 'unicode-test-key';
+
+        const encrypted = DyFM_Crypto.encrypt(unicodeData, key);
+        const decrypted = DyFM_Crypto.decrypt(encrypted, key);
+        expect(decrypted).toEqual(unicodeData);
+
+        // Multiple encryptions should be identical
+        const encrypted2 = DyFM_Crypto.encrypt(unicodeData, key);
+        expect(encrypted).toBe(encrypted2);
+      });
+
+      it('| should handle large data objects consistently', () => {
+        // Create a large object with many properties
+        const largeData: any = { id: 1 };
+        for (let i = 0; i < 100; i++) {
+          largeData[`prop${i}`] = `value${i}`;
+        }
+        const key = 'large-data-key';
+
+        const encrypted1 = DyFM_Crypto.encrypt(largeData, key);
+        const encrypted2 = DyFM_Crypto.encrypt(largeData, key);
+        expect(encrypted1).toBe(encrypted2);
+
+        const decrypted = DyFM_Crypto.decrypt(encrypted1, key);
+        expect(decrypted).toEqual(largeData);
+      });
+
+      it('| should handle nested circular references gracefully', () => {
+        const circularData: any = { id: 1, name: 'circular' };
+        circularData.self = circularData;
+        const key = 'circular-key';
+
+        // Should handle circular references without crashing
+        expect(() => {
+          const encrypted = DyFM_Crypto.encrypt(circularData, key);
+          // Note: JSON.stringify will fail on circular refs, so this test ensures graceful handling
+        }).toThrow(); // Expected to throw due to circular reference
+      });
+    });
+
+    describe('| Time-based stability tests', () => {
+      it('| should maintain consistency across time-based operations', () => {
+        const timeData = {
+          timestamp: new Date().toISOString(),
+          id: 1,
+          name: 'time-test'
+        };
+        const key = 'time-test-key';
+
+        // Encrypt same data multiple times
+        const encrypted1 = DyFM_Crypto.encrypt(timeData, key);
+        
+        // Simulate time passing
+        setTimeout(() => {
+          const encrypted2 = DyFM_Crypto.encrypt(timeData, key);
+          expect(encrypted1).toBe(encrypted2);
+        }, 100);
+      });
+
+      it('| should handle date objects consistently', () => {
+        const dateData = {
+          created: new Date('2024-01-01T00:00:00Z'),
+          updated: new Date('2024-12-31T23:59:59Z'),
+          id: 1
+        };
+        const key = 'date-test-key';
+
+        const encrypted1 = DyFM_Crypto.encrypt(dateData, key);
+        const encrypted2 = DyFM_Crypto.encrypt(dateData, key);
+        expect(encrypted1).toBe(encrypted2);
+
+        const decrypted = DyFM_Crypto.decrypt(encrypted1, key) as any;
+        // Compare ISO strings since JSON serialization converts dates to strings
+        expect(decrypted.created).toEqual(dateData.created.toISOString());
+        expect(decrypted.updated).toEqual(dateData.updated.toISOString());
+        expect(decrypted.id).toBe(dateData.id);
+      });
+    });
+
+    describe('| Memory and performance stability', () => {
+      it('| should handle multiple encryption/decryption cycles without memory leaks', () => {
+        const testData = { id: 1, name: 'memory-test' };
+        const key = 'memory-test-key';
+
+        // Perform many encryption/decryption cycles
+        for (let i = 0; i < 1000; i++) {
+          const encrypted = DyFM_Crypto.encrypt(testData, key);
+          const decrypted = DyFM_Crypto.decrypt(encrypted, key);
+          expect(decrypted).toEqual(testData);
+        }
+      });
+
+      it('| should maintain consistent performance across multiple operations', () => {
+        const testData = { id: 1, name: 'performance-test' };
+        const key = 'performance-test-key';
+
+        const startTime = Date.now();
+        
+        // Perform multiple operations
+        for (let i = 0; i < 100; i++) {
+          const encrypted = DyFM_Crypto.encrypt(testData, key);
+          const decrypted = DyFM_Crypto.decrypt(encrypted, key);
+          expect(decrypted).toEqual(testData);
+        }
+
+        const endTime = Date.now();
+        const duration = endTime - startTime;
+        
+        // Should complete within reasonable time (adjust threshold as needed)
+        expect(duration).toBeLessThan(6000); // 6 seconds max
+      });
+    });
+  });
+
+  describe('| URL-safe base64 transmission edge cases', () => {
+    it('| should handle encrypted data that loses padding during URL transmission', () => {
+      const encrypted = DyFM_Crypto.encrypt(testData, testKey);
+      // Simulate padding loss during URL transmission
+      // Encrypted data already has no padding (removed in encrypt), so this tests normal behavior
+      expect(() => DyFM_Crypto.decrypt(encrypted, testKey)).not.toThrow();
+      const decrypted = DyFM_Crypto.decrypt(encrypted, testKey);
+      expect(decrypted).toEqual(testData);
+    });
+
+    it('| should handle encrypted data with 0 padding characters (normal case)', () => {
+      const encrypted = DyFM_Crypto.encrypt(testData, testKey);
+      // Encrypted data has no padding (removed by .replace(/=+$/, ''))
+      expect(encrypted).not.toContain('=');
+      expect(() => DyFM_Crypto.decrypt(encrypted, testKey)).not.toThrow();
+      const decrypted = DyFM_Crypto.decrypt(encrypted, testKey);
+      expect(decrypted).toEqual(testData);
+    });
+
+    it('| should handle encrypted data that would need 1 padding character', () => {
+      // Create a scenario where base64 would need 1 padding char
+      // This is tested by encrypting and verifying it works without padding
+      const encrypted = DyFM_Crypto.encrypt(testData, testKey);
+      // If the encrypted string length % 4 === 3, it would need 1 padding char
+      // But since padding is removed, we verify it still works
+      expect(() => DyFM_Crypto.decrypt(encrypted, testKey)).not.toThrow();
+    });
+
+    it('| should handle encrypted data that would need 2 padding characters', () => {
+      // Create a scenario where base64 would need 2 padding chars
+      const encrypted = DyFM_Crypto.encrypt(testData, testKey);
+      // If the encrypted string length % 4 === 2, it would need 2 padding chars
+      // Verify it works without explicit padding
+      expect(() => DyFM_Crypto.decrypt(encrypted, testKey)).not.toThrow();
+    });
+
+    it('| should handle encrypted data that would need 3 padding characters', () => {
+      // Create a scenario where base64 would need 3 padding chars
+      const encrypted = DyFM_Crypto.encrypt(testData, testKey);
+      // If the encrypted string length % 4 === 1, it would need 3 padding chars
+      // Verify it works without explicit padding
+      expect(() => DyFM_Crypto.decrypt(encrypted, testKey)).not.toThrow();
+    });
+
+    it('| should handle base64 strings that are valid but too short after parsing', () => {
+      // Create a valid URL-safe base64 string that's too short
+      const validButShort = 'ABCDEFGHIJKLMNOPQRSTUVWXY'; // 25 chars, valid format but too short
+      expect(() => DyFM_Crypto.decrypt(validButShort, testKey)).toThrow();
+    });
+
+    it('| should handle round-trip encryption/decryption with padding edge cases', () => {
+      // Test that encryption/decryption works correctly even when padding is removed
+      const testCases = [
+        { id: 1, name: 'test' },
+        { id: 2, data: 'short' },
+        { id: 3, data: 'A'.repeat(100) }, // Longer data
+        { id: 4, nested: { value: true } }
+      ];
+
+      testCases.forEach(testCase => {
+        const encrypted = DyFM_Crypto.encrypt(testCase, testKey);
+        // Verify no padding in encrypted string
+        expect(encrypted).not.toContain('=');
+        // Verify round-trip works
+        const decrypted = DyFM_Crypto.decrypt(encrypted, testKey);
+        expect(decrypted).toEqual(testCase);
+      });
+    });
+
+    it('| should handle URL-safe base64 conversion correctly', () => {
+      const encrypted = DyFM_Crypto.encrypt(testData, testKey);
+      // Verify it's URL-safe (no +, /, or =)
+      expect(encrypted).not.toContain('+');
+      expect(encrypted).not.toContain('/');
+      expect(encrypted).not.toContain('=');
+      // Verify it can be decrypted
+      expect(() => DyFM_Crypto.decrypt(encrypted, testKey)).not.toThrow();
+    });
+
+    it('| should handle base64 strings with various padding scenarios in transmission', () => {
+      const encrypted = DyFM_Crypto.encrypt(testData, testKey);
+      
+      // Simulate different padding scenarios that might occur during transmission
+      // Even though encrypted data has no padding, test that decryption handles it
+      const scenarios = [
+        encrypted, // No padding (normal)
+        encrypted + '=', // 1 padding char added
+        encrypted + '==', // 2 padding chars added
+        encrypted + '===' // 3 padding chars added
+      ];
+
+      // The first one should work (no padding)
+      expect(() => DyFM_Crypto.decrypt(scenarios[0], testKey)).not.toThrow();
+      
+      // Others might work or fail depending on base64 parsing
+      scenarios.slice(1).forEach((scenario, index) => {
+        // These might work if CryptoJS handles padding, or fail if data is corrupted
+        try {
+          const decrypted = DyFM_Crypto.decrypt(scenario, testKey);
+          expect(decrypted).toEqual(testData);
+        } catch {
+          // If it fails, that's also acceptable as extra padding shouldn't be there
+          expect(() => DyFM_Crypto.decrypt(scenario, testKey)).toThrow();
+        }
+      });
+    });
+
+    it('| should handle URL encoding/decoding edge cases', () => {
+      const encrypted = DyFM_Crypto.encrypt(testData, testKey);
+      
+      // Simulate URL encoding (though encrypted data should already be URL-safe)
+      // Test that the encrypted string works in URL contexts
+      const urlEncoded = encodeURIComponent(encrypted);
+      const urlDecoded = decodeURIComponent(urlEncoded);
+      
+      // Should be able to decrypt after URL encoding/decoding
+      expect(() => DyFM_Crypto.decrypt(urlDecoded, testKey)).not.toThrow();
+      const decrypted = DyFM_Crypto.decrypt(urlDecoded, testKey);
+      expect(decrypted).toEqual(testData);
+    });
+
+    it('| should handle base64 strings that are valid format but truncated', () => {
+      const encrypted = DyFM_Crypto.encrypt(testData, testKey);
+      // Truncate to various lengths that are still valid base64 format
+      const truncationPoints = [
+        Math.floor(encrypted.length * 0.5),
+        Math.floor(encrypted.length * 0.75),
+        encrypted.length - 5,
+        encrypted.length - 10
+      ];
+
+      truncationPoints.forEach(point => {
+        const truncated = encrypted.substring(0, point);
+        // Should throw error for truncated data
+        expect(() => DyFM_Crypto.decrypt(truncated, testKey)).toThrow();
+      });
+    });
+  });
+
 });