@futdevpro/fsm-dynamo 1.16.38 → 1.16.40

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

@@ -1,606 +1,606 @@
-import { DyFM_Crypto } from './crypto.util';
-
-describe('| DyFM_Crypto edge cases', () => {
-  const testKey = 'test-secret-key-123';
-  const testData = { id: 1, name: 'test' };
-
-  describe('| edge cases', () => {
-    describe('| empty and null values', () => {
-      it('| should handle empty objects', () => {
-        const emptyObj = {};
-        const encrypted = DyFM_Crypto.encrypt(emptyObj, testKey);
-        const decrypted = DyFM_Crypto.decrypt(encrypted, testKey);
-        expect(decrypted).toEqual(emptyObj);
-      });
-
-      it('| should handle empty arrays', () => {
-        const emptyArr: any[] = [];
-        const encrypted = DyFM_Crypto.encrypt(emptyArr, testKey);
-        const decrypted = DyFM_Crypto.decrypt(encrypted, testKey);
-        expect(decrypted).toEqual(emptyArr);
-      });
-
-      it('| should handle null values in objects', () => {
-        const dataWithNull = {
-          id: 1,
-          name: null,
-          nested: { value: null }
-        };
-        const encrypted = DyFM_Crypto.encrypt(dataWithNull, testKey);
-        const decrypted = DyFM_Crypto.decrypt(encrypted, testKey);
-        expect(decrypted).toEqual(dataWithNull);
-      });
-
-      it('| should handle undefined values in objects', () => {
-        const dataWithUndefined = {
-          id: 1,
-          name: undefined,
-          nested: { value: undefined }
-        };
-        const encrypted = DyFM_Crypto.encrypt(dataWithUndefined, testKey);
-        const decrypted = DyFM_Crypto.decrypt(encrypted, testKey);
-        expect(decrypted).toEqual({ id: 1, nested: {} });
-      });
-    });
-
-    describe('| key edge cases', () => {
-      it('| should handle very long keys', () => {
-        const longKey = 'a'.repeat(1000);
-        const encrypted = DyFM_Crypto.encrypt(testData, longKey);
-        const decrypted = DyFM_Crypto.decrypt(encrypted, longKey);
-        expect(decrypted).toEqual(testData);
-      });
-
-      it('| should handle empty key', () => {
-        expect(() => DyFM_Crypto.encrypt(testData, '')).toThrow();
-      });
-
-      it('| should handle whitespace-only keys', () => {
-        expect(() => DyFM_Crypto.encrypt(testData, '   ')).toThrow();
-      });
-    });
-
-    describe('| encrypted data manipulation', () => {
-      it('| should detect when encrypted data is truncated', () => {
-        const encrypted = DyFM_Crypto.encrypt(testData, testKey);
-        const truncated = encrypted.slice(0, -10);
-        expect(() => DyFM_Crypto.decrypt(truncated, testKey)).toThrow();
-      });
-
-      it('| should detect when encrypted data is extended', () => {
-        const encrypted = DyFM_Crypto.encrypt(testData, testKey);
-        const extended = encrypted + 'A'.repeat(10);
-        expect(() => DyFM_Crypto.decrypt(extended, testKey)).toThrow();
-      });
-
-      it('| should detect when encrypted data is modified in the middle', () => {
-        const encrypted = DyFM_Crypto.encrypt(testData, testKey);
-        const midPoint = Math.floor(encrypted.length / 2);
-        const modified = encrypted.slice(0, midPoint) + 'X' + encrypted.slice(midPoint + 1);
-        expect(() => DyFM_Crypto.decrypt(modified, testKey)).toThrow();
-      });
-    });
-
-    describe('| JSON handling edge cases', () => {
-      it('| should handle double-stringified JSON data correctly', () => {
-        const testData = {
-          username: 'Itharen',
-          password: 'asdasd',
-          roles: [],
-          permissions: [],
-          activeSubscriptions: [],
-          clientUserIds: {},
-          oauth2Data: {}
-        };
-
-        // Simulate double stringification
-        const doubleStringified = JSON.stringify(JSON.stringify(testData));
-        
-        const encrypted = DyFM_Crypto.encrypt(doubleStringified, testKey);
-        const decrypted = DyFM_Crypto.decrypt(encrypted, testKey);
-
-        // The crypto utility should automatically handle double-stringified JSON
-        // and return the original object directly
-        expect(decrypted).toEqual(testData);
-      });
-
-      xit('| should handle character-by-character JSON data correctly', () => {
-        // Create a character-by-character object like in the example
-        const charByCharData = {
-          '0': '{',
-          '1': '"',
-          '2': '_',
-          '3': '_',
-          '4': 'c',
-          '5': 'r',
-          '6': 'e',
-          '7': 'a',
-          '8': 't',
-          '9': 'e',
-          '10': 'd',
-          '11': '"',
-          '12': ':',
-          '13': '"',
-          '14': '2',
-          '15': '0',
-          '16': '2',
-          '17': '5',
-          '18': '-',
-          '19': '0',
-          '20': '5',
-          '21': '-',
-          '22': '1',
-          '23': '3',
-          '24': 'T',
-          '25': '1',
-          '26': '0',
-          '27': ':',
-          '28': '4',
-          '29': '0',
-          '30': ':',
-          '31': '4',
-          '32': '4',
-          '33': '.',
-          '34': '7',
-          '35': '6',
-          '36': '0',
-          '37': 'Z',
-          '38': '"',
-          '39': ',',
-          '40': '"',
-          '41': '_',
-          '42': '_',
-          '43': 'l',
-          '44': 'a',
-          '45': 's',
-          '46': 't',
-          '47': 'M',
-          '48': 'o',
-          '49': 'd',
-          '50': 'i',
-          '51': 'f',
-          '52': 'i',
-          '53': 'e',
-          '54': 'd',
-          '55': '"',
-          '56': ':',
-          '57': '"',
-          '58': '2',
-          '59': '0',
-          '60': '2',
-          '61': '5',
-          '62': '-',
-          '63': '0',
-          '64': '5',
-          '65': '-',
-          '66': '1',
-          '67': '3',
-          '68': 'T',
-          '69': '1',
-          '70': '0',
-          '71': ':',
-          '72': '4',
-          '73': '0',
-          '74': ':',
-          '75': '4',
-          '76': '4',
-          '77': '.',
-          '78': '7',
-          '79': '6',
-          '80': '0',
-          '81': 'Z',
-          '82': '"',
-          '83': ',',
-          '84': '"',
-          '85': '_',
-          '86': '_',
-          '87': 'v',
-          '88': '"',
-          '89': ':',
-          '90': '0',
-          '91': ',',
-          '92': '"',
-          '93': 'u',
-          '94': 's',
-          '95': 'e',
-          '96': 'r',
-          '97': 'n',
-          '98': 'a',
-          '99': 'm',
-          '100': 'e',
-          '101': '"',
-          '102': ':',
-          '103': '"',
-          '104': 'I',
-          '105': 't',
-          '106': 'h',
-          '107': 'a',
-          '108': 'r',
-          '109': 'e',
-          '110': 'n',
-          '111': '"',
-          '112': ',',
-          '113': '"',
-          '114': 'p',
-          '115': 'r',
-          '116': 'e',
-          '117': 'v',
-          '118': 'i',
-          '119': 'o',
-          '120': 'u',
-          '121': 's',
-          '122': 'E',
-          '123': 'm',
-          '124': 'a',
-          '125': 'i',
-          '126': 'l',
-          '127': 's',
-          '128': '"',
-          '129': ':',
-          '130': '[',
-          '131': ']',
-          '132': ',',
-          '133': '"',
-          '134': 'p',
-          '135': 'a',
-          '136': 's',
-          '137': 's',
-          '138': 'w',
-          '139': 'o',
-          '140': 'r',
-          '141': 'd',
-          '142': '"',
-          '143': ':',
-          '144': '"',
-          '145': 'a',
-          '146': 's',
-          '147': 'd',
-          '148': 'a',
-          '149': 's',
-          '150': 'd',
-          '151': '"',
-          '152': ',',
-          '153': '"',
-          '154': 'r',
-          '155': 'o',
-          '156': 'l',
-          '157': 'e',
-          '158': 's',
-          '159': '"',
-          '160': ':',
-          '161': '[',
-          '162': ']',
-          '163': ',',
-          '164': '"',
-          '165': 'p',
-          '166': 'e',
-          '167': 'r',
-          '168': 'm',
-          '169': 'i',
-          '170': 's',
-          '171': 's',
-          '172': 'i',
-          '173': 'o',
-          '174': 'n',
-          '175': 's',
-          '176': '"',
-          '177': ':',
-          '178': '[',
-          '179': ']',
-          '180': ',',
-          '181': '"',
-          '182': 'a',
-          '183': 'c',
-          '184': 't',
-          '185': 'i',
-          '186': 'v',
-          '187': 'e',
-          '188': 'S',
-          '189': 'u',
-          '190': 'b',
-          '191': 's',
-          '192': 'c',
-          '193': 'r',
-          '194': 'i',
-          '195': 'p',
-          '196': 't',
-          '197': 'i',
-          '198': 'o',
-          '199': 'n',
-          '200': 's',
-          '201': '"',
-          '202': ':',
-          '203': '[',
-          '204': ']',
-          '205': ',',
-          '206': '"',
-          '207': 'c',
-          '208': 'l',
-          '209': 'i',
-          '210': 'e',
-          '211': 'n',
-          '212': 't',
-          '213': 'U',
-          '214': 's',
-          '215': 'e',
-          '216': 'r',
-          '217': 'I',
-          '218': 'd',
-          '219': 's',
-          '220': '"',
-          '221': ':',
-          '222': '{',
-          '223': '}',
-          '224': ',',
-          '225': '"',
-          '226': 'o',
-          '227': 'a',
-          '228': 'u',
-          '229': 't',
-          '230': 'h',
-          '231': '2',
-          '232': 'D',
-          '233': 'a',
-          '234': 't',
-          '235': 'a',
-          '236': '"',
-          '237': ':',
-          '238': '{',
-          '239': '}',
-          '240': '}'
-        };
-
-        const encrypted = DyFM_Crypto.encrypt(charByCharData, testKey);
-        const decrypted = DyFM_Crypto.decrypt(encrypted, testKey);
-
-        // Should be able to parse the decrypted data back to the original object
-        expect(decrypted).toEqual(charByCharData);
-      });
-    });
-
-    describe('| cross-environment consistency', () => {
-      it('| should produce same encrypted output for same input across different environments', () => {
-        const testData = {
-          id: 1,
-          name: 'test',
-          timestamp: '2024-03-20T10:00:00Z'
-        };
-        const key = 'test-secret-key-123';
-
-        // Simulate different environments by creating new instances
-        const encrypted1 = DyFM_Crypto.encrypt(testData, key);
-        const encrypted2 = DyFM_Crypto.encrypt(testData, key);
-
-        expect(encrypted1).toBe(encrypted2);
-        expect(DyFM_Crypto.decrypt(encrypted1, key)).toEqual(testData);
-        expect(DyFM_Crypto.decrypt(encrypted2, key)).toEqual(testData);
-      });
-
-      it('| should maintain encryption consistency with different data types', () => {
-        const testCases = [
-          { data: { id: 1 }, key: 'key1' },
-          { data: 'string data', key: 'key2' },
-          { data: [1, 2, 3], key: 'key3' },
-          { data: { nested: { value: true } }, key: 'key4' }
-        ];
-
-        testCases.forEach(({ data, key }) => {
-          const encrypted1 = DyFM_Crypto.encrypt(data, key);
-          const encrypted2 = DyFM_Crypto.encrypt(data, key);
-          expect(encrypted1).toBe(encrypted2);
-        });
-      });
-    });
-
-    describe('| database persistence', () => {
-      interface UserData {
-        id: number;
-        name: string;
-        lastLogin: string;
-        preferences: {
-          language: string;
-          timezone: string;
-        };
-      }
-
-      it('| should successfully encrypt and decrypt data after database storage simulation', () => {
-        const originalData = {
-          id: 1,
-          name: 'test user',
-          email: 'test@example.com',
-          settings: {
-            theme: 'dark',
-            notifications: true
-          }
-        };
-        const key = 'db-storage-key';
-
-        // Simulate database storage and retrieval
-        const encrypted = DyFM_Crypto.encrypt(originalData, key);
-        const storedData = encrypted; // Simulating database storage
-        const retrievedData = storedData; // Simulating database retrieval
-        const decrypted = DyFM_Crypto.decrypt(retrievedData, key);
-
-        expect(decrypted).toEqual(originalData);
-      });
-
-      it('| should handle multiple encryption/decryption cycles for database operations', () => {
-        const userData: UserData = {
-          id: 1,
-          name: 'test user',
-          lastLogin: '2024-01-01T10:00:00.000Z',
-          preferences: {
-            language: 'en',
-            timezone: 'UTC'
-          }
-        };
-        const key = 'persistent-key';
-
-        // Simulate multiple database operations
-        const encrypted1 = DyFM_Crypto.encrypt(userData, key);
-        const decrypted1 = DyFM_Crypto.decrypt(encrypted1, key) as UserData;
-        
-        // Simulate data update with a different timestamp
-        const updatedData: UserData = { 
-          ...decrypted1, 
-          lastLogin: '2024-01-02T15:30:00.000Z'
-        };
-        const encrypted2 = DyFM_Crypto.encrypt(updatedData, key);
-        const decrypted2 = DyFM_Crypto.decrypt(encrypted2, key) as UserData;
-
-        expect(decrypted1).toEqual(userData);
-        expect(decrypted2).toEqual(updatedData);
-        expect(decrypted2.lastLogin).not.toBe(userData.lastLogin);
-      });
-
-      it('| should maintain data integrity through multiple database operations', () => {
-        const sensitiveData = {
-          id: 1,
-          password: 'hashed-password-123',
-          securityQuestions: [
-            { question: 'What is your pet name?', answer: 'Fluffy' },
-            { question: 'Where were you born?', answer: 'New York' }
-          ]
-        };
-        const key = 'sensitive-data-key';
-
-        // Simulate multiple database operations with the same data
-        const encrypted1 = DyFM_Crypto.encrypt(sensitiveData, key);
-        const decrypted1 = DyFM_Crypto.decrypt(encrypted1, key);
-        const encrypted2 = DyFM_Crypto.encrypt(decrypted1, key);
-        const decrypted2 = DyFM_Crypto.decrypt(encrypted2, key);
-
-        expect(decrypted1).toEqual(sensitiveData);
-        expect(decrypted2).toEqual(sensitiveData);
-        expect(encrypted1).toBe(encrypted2); // Different encryption instances
-      });
-    });
-
-    describe('| special characters', () => {
-      it('| should handle Unicode characters', () => {
-        const unicodeData = {
-          text: 'Hello 世界! 🌍',
-          emoji: '👋',
-          special: '!!!@@@###$$$%%%^^^&&&***((()))___+++---===[[[]]]{{{}}}|||;;;:::,,,...<<<>>>' +
-            'ĐĐĐđđđßßߤ¤¤×××÷÷÷¨¨¨¨~~~ˇˇˇ^^^˘˘˘°°°˛˛˛```˙˙˙´´´˝˝˝˝¸¸¸§§§' +
-            '???ééééáááűűűúúúőőőóóóüüüöööíííÉÉÉÁÁÁŰŰŰÚÚÚŐŐŐÓÓÓÜÖÖÖÍÍÍ'
-        };
-        const encrypted = DyFM_Crypto.encrypt(unicodeData, testKey);
-        const decrypted = DyFM_Crypto.decrypt(encrypted, testKey);
-        expect(decrypted).toEqual(unicodeData);
-      });
-
-      it('| should handle special characters in object keys', () => {
-        const specialKeyData = {
-          'key-with-spaces': 'value',
-          'key.with.dots': 'value',
-          'key-with-special-chars!@#': 'value',
-          'key-with-unicode-世界': 'value'
-        };
-        const encrypted = DyFM_Crypto.encrypt(specialKeyData, testKey);
-        const decrypted = DyFM_Crypto.decrypt(encrypted, testKey);
-        expect(decrypted).toEqual(specialKeyData);
-      });
-
-      it('| should handle special characters in nested objects', () => {
-        const nestedData = {
-          level1: {
-            'special-key!@#': {
-              'nested-key-世界': 'value with special chars!@#'
-            }
-          }
-        };
-        const encrypted = DyFM_Crypto.encrypt(nestedData, testKey);
-        const decrypted = DyFM_Crypto.decrypt(encrypted, testKey);
-        expect(decrypted).toEqual(nestedData);
-      });
-
-      it('| should handle special characters in arrays', () => {
-        const arrayData = [
-          'Hello 世界!',
-          { 'special-key': 'value with !@#' },
-          ['nested', 'array', 'with', 'special', 'chars!@#']
-        ];
-        const encrypted = DyFM_Crypto.encrypt(arrayData, testKey);
-        const decrypted = DyFM_Crypto.decrypt(encrypted, testKey);
-        expect(decrypted).toEqual(arrayData);
-      });
-    });
-
-    describe('| base64 padding and parsing edge cases', () => {
-      it('| should handle encrypted data missing 1 padding character', () => {
-        const encrypted = DyFM_Crypto.encrypt(testData, testKey);
-        // Remove last character (which might be padding)
-        const withoutPadding = encrypted.slice(0, -1);
-        expect(() => DyFM_Crypto.decrypt(withoutPadding, testKey)).toThrow();
-      });
-
-      it('| should handle encrypted data missing 2 padding characters', () => {
-        const encrypted = DyFM_Crypto.encrypt(testData, testKey);
-        // Remove last 2 characters
-        const withoutPadding = encrypted.slice(0, -2);
-        expect(() => DyFM_Crypto.decrypt(withoutPadding, testKey)).toThrow();
-      });
-
-      it('| should handle encrypted data missing 3 padding characters', () => {
-        const encrypted = DyFM_Crypto.encrypt(testData, testKey);
-        // Remove last 3 characters
-        const withoutPadding = encrypted.slice(0, -3);
-        expect(() => DyFM_Crypto.decrypt(withoutPadding, testKey)).toThrow();
-      });
-
-      it('| should detect base64 strings that are too short to be valid (less than 48 bytes)', () => {
-        // Create a minimal base64 string that parses to less than 48 bytes
-        // 18 bytes = 24 base64 characters (18 * 4/3 = 24)
-        const shortBase64 = 'ABCDEFGHIJKLMNOPQRSTUVW'; // 24 chars = 18 bytes when parsed
-        expect(() => DyFM_Crypto.decrypt(shortBase64, testKey)).toThrow();
-      });
-
-      it('| should handle base64 strings with incorrect padding', () => {
-        const encrypted = DyFM_Crypto.encrypt(testData, testKey);
-        // Add incorrect padding characters
-        const withIncorrectPadding = encrypted + '====';
-        expect(() => DyFM_Crypto.decrypt(withIncorrectPadding, testKey)).toThrow();
-      });
-
-      it('| should handle URL-safe base64 strings ending with dash', () => {
-        // Create a base64 string ending with '-' (which becomes '+' in regular base64)
-        const encrypted = DyFM_Crypto.encrypt(testData, testKey);
-        // Replace last character with dash if it's not already
-        const withDash = encrypted.slice(0, -1) + '-';
-        expect(() => DyFM_Crypto.decrypt(withDash, testKey)).toThrow();
-      });
-
-      it('| should handle URL-safe base64 strings ending with underscore', () => {
-        // Create a base64 string ending with '_' (which becomes '/' in regular base64)
-        const encrypted = DyFM_Crypto.encrypt(testData, testKey);
-        // Replace last character with underscore if it's not already
-        const withUnderscore = encrypted.slice(0, -1) + '_';
-        expect(() => DyFM_Crypto.decrypt(withUnderscore, testKey)).toThrow();
-      });
-
-      it('| should handle URL-safe base64 strings with no padding characters', () => {
-        const encrypted = DyFM_Crypto.encrypt(testData, testKey);
-        // Encrypted data should already have no padding (removed in encrypt method)
-        // This test verifies that decryption works without padding
-        expect(() => DyFM_Crypto.decrypt(encrypted, testKey)).not.toThrow();
-        const decrypted = DyFM_Crypto.decrypt(encrypted, testKey);
-        expect(decrypted).toEqual(testData);
-      });
-
-      it('| should handle very short base64 strings that parse to exactly 18 bytes', () => {
-        // Create a base64 string that parses to exactly 18 bytes
-        // 18 bytes = 24 base64 characters
-        const exactly18Bytes = 'ABCDEFGHIJKLMNOPQRSTUVWX'; // 24 chars
-        expect(() => DyFM_Crypto.decrypt(exactly18Bytes, testKey)).toThrow();
-      });
-
-      it('| should handle base64 strings that are valid format but too short after parsing', () => {
-        // Create a valid URL-safe base64 string that's too short
-        const validButShort = 'ABCDEFGHIJKLMNOPQRSTUVWXY'; // 25 chars, valid format
-        expect(() => DyFM_Crypto.decrypt(validButShort, testKey)).toThrow();
-      });
-    });
-  });
-
+import { DyFM_Crypto } from './crypto.util';
+
+describe('| DyFM_Crypto edge cases', () => {
+  const testKey = 'test-secret-key-123';
+  const testData = { id: 1, name: 'test' };
+
+  describe('| edge cases', () => {
+    describe('| empty and null values', () => {
+      it('| should handle empty objects', () => {
+        const emptyObj = {};
+        const encrypted = DyFM_Crypto.encrypt(emptyObj, testKey);
+        const decrypted = DyFM_Crypto.decrypt(encrypted, testKey);
+        expect(decrypted).toEqual(emptyObj);
+      });
+
+      it('| should handle empty arrays', () => {
+        const emptyArr: any[] = [];
+        const encrypted = DyFM_Crypto.encrypt(emptyArr, testKey);
+        const decrypted = DyFM_Crypto.decrypt(encrypted, testKey);
+        expect(decrypted).toEqual(emptyArr);
+      });
+
+      it('| should handle null values in objects', () => {
+        const dataWithNull = {
+          id: 1,
+          name: null,
+          nested: { value: null }
+        };
+        const encrypted = DyFM_Crypto.encrypt(dataWithNull, testKey);
+        const decrypted = DyFM_Crypto.decrypt(encrypted, testKey);
+        expect(decrypted).toEqual(dataWithNull);
+      });
+
+      it('| should handle undefined values in objects', () => {
+        const dataWithUndefined = {
+          id: 1,
+          name: undefined,
+          nested: { value: undefined }
+        };
+        const encrypted = DyFM_Crypto.encrypt(dataWithUndefined, testKey);
+        const decrypted = DyFM_Crypto.decrypt(encrypted, testKey);
+        expect(decrypted).toEqual({ id: 1, nested: {} });
+      });
+    });
+
+    describe('| key edge cases', () => {
+      it('| should handle very long keys', () => {
+        const longKey = 'a'.repeat(1000);
+        const encrypted = DyFM_Crypto.encrypt(testData, longKey);
+        const decrypted = DyFM_Crypto.decrypt(encrypted, longKey);
+        expect(decrypted).toEqual(testData);
+      });
+
+      it('| should handle empty key', () => {
+        expect(() => DyFM_Crypto.encrypt(testData, '')).toThrow();
+      });
+
+      it('| should handle whitespace-only keys', () => {
+        expect(() => DyFM_Crypto.encrypt(testData, '   ')).toThrow();
+      });
+    });
+
+    describe('| encrypted data manipulation', () => {
+      it('| should detect when encrypted data is truncated', () => {
+        const encrypted = DyFM_Crypto.encrypt(testData, testKey);
+        const truncated = encrypted.slice(0, -10);
+        expect(() => DyFM_Crypto.decrypt(truncated, testKey)).toThrow();
+      });
+
+      it('| should detect when encrypted data is extended', () => {
+        const encrypted = DyFM_Crypto.encrypt(testData, testKey);
+        const extended = encrypted + 'A'.repeat(10);
+        expect(() => DyFM_Crypto.decrypt(extended, testKey)).toThrow();
+      });
+
+      it('| should detect when encrypted data is modified in the middle', () => {
+        const encrypted = DyFM_Crypto.encrypt(testData, testKey);
+        const midPoint = Math.floor(encrypted.length / 2);
+        const modified = encrypted.slice(0, midPoint) + 'X' + encrypted.slice(midPoint + 1);
+        expect(() => DyFM_Crypto.decrypt(modified, testKey)).toThrow();
+      });
+    });
+
+    describe('| JSON handling edge cases', () => {
+      it('| should handle double-stringified JSON data correctly', () => {
+        const testData = {
+          username: 'Itharen',
+          password: 'asdasd',
+          roles: [],
+          permissions: [],
+          activeSubscriptions: [],
+          clientUserIds: {},
+          oauth2Data: {}
+        };
+
+        // Simulate double stringification
+        const doubleStringified = JSON.stringify(JSON.stringify(testData));
+        
+        const encrypted = DyFM_Crypto.encrypt(doubleStringified, testKey);
+        const decrypted = DyFM_Crypto.decrypt(encrypted, testKey);
+
+        // The crypto utility should automatically handle double-stringified JSON
+        // and return the original object directly
+        expect(decrypted).toEqual(testData);
+      });
+
+      xit('| should handle character-by-character JSON data correctly', () => {
+        // Create a character-by-character object like in the example
+        const charByCharData = {
+          '0': '{',
+          '1': '"',
+          '2': '_',
+          '3': '_',
+          '4': 'c',
+          '5': 'r',
+          '6': 'e',
+          '7': 'a',
+          '8': 't',
+          '9': 'e',
+          '10': 'd',
+          '11': '"',
+          '12': ':',
+          '13': '"',
+          '14': '2',
+          '15': '0',
+          '16': '2',
+          '17': '5',
+          '18': '-',
+          '19': '0',
+          '20': '5',
+          '21': '-',
+          '22': '1',
+          '23': '3',
+          '24': 'T',
+          '25': '1',
+          '26': '0',
+          '27': ':',
+          '28': '4',
+          '29': '0',
+          '30': ':',
+          '31': '4',
+          '32': '4',
+          '33': '.',
+          '34': '7',
+          '35': '6',
+          '36': '0',
+          '37': 'Z',
+          '38': '"',
+          '39': ',',
+          '40': '"',
+          '41': '_',
+          '42': '_',
+          '43': 'l',
+          '44': 'a',
+          '45': 's',
+          '46': 't',
+          '47': 'M',
+          '48': 'o',
+          '49': 'd',
+          '50': 'i',
+          '51': 'f',
+          '52': 'i',
+          '53': 'e',
+          '54': 'd',
+          '55': '"',
+          '56': ':',
+          '57': '"',
+          '58': '2',
+          '59': '0',
+          '60': '2',
+          '61': '5',
+          '62': '-',
+          '63': '0',
+          '64': '5',
+          '65': '-',
+          '66': '1',
+          '67': '3',
+          '68': 'T',
+          '69': '1',
+          '70': '0',
+          '71': ':',
+          '72': '4',
+          '73': '0',
+          '74': ':',
+          '75': '4',
+          '76': '4',
+          '77': '.',
+          '78': '7',
+          '79': '6',
+          '80': '0',
+          '81': 'Z',
+          '82': '"',
+          '83': ',',
+          '84': '"',
+          '85': '_',
+          '86': '_',
+          '87': 'v',
+          '88': '"',
+          '89': ':',
+          '90': '0',
+          '91': ',',
+          '92': '"',
+          '93': 'u',
+          '94': 's',
+          '95': 'e',
+          '96': 'r',
+          '97': 'n',
+          '98': 'a',
+          '99': 'm',
+          '100': 'e',
+          '101': '"',
+          '102': ':',
+          '103': '"',
+          '104': 'I',
+          '105': 't',
+          '106': 'h',
+          '107': 'a',
+          '108': 'r',
+          '109': 'e',
+          '110': 'n',
+          '111': '"',
+          '112': ',',
+          '113': '"',
+          '114': 'p',
+          '115': 'r',
+          '116': 'e',
+          '117': 'v',
+          '118': 'i',
+          '119': 'o',
+          '120': 'u',
+          '121': 's',
+          '122': 'E',
+          '123': 'm',
+          '124': 'a',
+          '125': 'i',
+          '126': 'l',
+          '127': 's',
+          '128': '"',
+          '129': ':',
+          '130': '[',
+          '131': ']',
+          '132': ',',
+          '133': '"',
+          '134': 'p',
+          '135': 'a',
+          '136': 's',
+          '137': 's',
+          '138': 'w',
+          '139': 'o',
+          '140': 'r',
+          '141': 'd',
+          '142': '"',
+          '143': ':',
+          '144': '"',
+          '145': 'a',
+          '146': 's',
+          '147': 'd',
+          '148': 'a',
+          '149': 's',
+          '150': 'd',
+          '151': '"',
+          '152': ',',
+          '153': '"',
+          '154': 'r',
+          '155': 'o',
+          '156': 'l',
+          '157': 'e',
+          '158': 's',
+          '159': '"',
+          '160': ':',
+          '161': '[',
+          '162': ']',
+          '163': ',',
+          '164': '"',
+          '165': 'p',
+          '166': 'e',
+          '167': 'r',
+          '168': 'm',
+          '169': 'i',
+          '170': 's',
+          '171': 's',
+          '172': 'i',
+          '173': 'o',
+          '174': 'n',
+          '175': 's',
+          '176': '"',
+          '177': ':',
+          '178': '[',
+          '179': ']',
+          '180': ',',
+          '181': '"',
+          '182': 'a',
+          '183': 'c',
+          '184': 't',
+          '185': 'i',
+          '186': 'v',
+          '187': 'e',
+          '188': 'S',
+          '189': 'u',
+          '190': 'b',
+          '191': 's',
+          '192': 'c',
+          '193': 'r',
+          '194': 'i',
+          '195': 'p',
+          '196': 't',
+          '197': 'i',
+          '198': 'o',
+          '199': 'n',
+          '200': 's',
+          '201': '"',
+          '202': ':',
+          '203': '[',
+          '204': ']',
+          '205': ',',
+          '206': '"',
+          '207': 'c',
+          '208': 'l',
+          '209': 'i',
+          '210': 'e',
+          '211': 'n',
+          '212': 't',
+          '213': 'U',
+          '214': 's',
+          '215': 'e',
+          '216': 'r',
+          '217': 'I',
+          '218': 'd',
+          '219': 's',
+          '220': '"',
+          '221': ':',
+          '222': '{',
+          '223': '}',
+          '224': ',',
+          '225': '"',
+          '226': 'o',
+          '227': 'a',
+          '228': 'u',
+          '229': 't',
+          '230': 'h',
+          '231': '2',
+          '232': 'D',
+          '233': 'a',
+          '234': 't',
+          '235': 'a',
+          '236': '"',
+          '237': ':',
+          '238': '{',
+          '239': '}',
+          '240': '}'
+        };
+
+        const encrypted = DyFM_Crypto.encrypt(charByCharData, testKey);
+        const decrypted = DyFM_Crypto.decrypt(encrypted, testKey);
+
+        // Should be able to parse the decrypted data back to the original object
+        expect(decrypted).toEqual(charByCharData);
+      });
+    });
+
+    describe('| cross-environment consistency', () => {
+      it('| should produce same encrypted output for same input across different environments', () => {
+        const testData = {
+          id: 1,
+          name: 'test',
+          timestamp: '2024-03-20T10:00:00Z'
+        };
+        const key = 'test-secret-key-123';
+
+        // Simulate different environments by creating new instances
+        const encrypted1 = DyFM_Crypto.encrypt(testData, key);
+        const encrypted2 = DyFM_Crypto.encrypt(testData, key);
+
+        expect(encrypted1).toBe(encrypted2);
+        expect(DyFM_Crypto.decrypt(encrypted1, key)).toEqual(testData);
+        expect(DyFM_Crypto.decrypt(encrypted2, key)).toEqual(testData);
+      });
+
+      it('| should maintain encryption consistency with different data types', () => {
+        const testCases = [
+          { data: { id: 1 }, key: 'key1' },
+          { data: 'string data', key: 'key2' },
+          { data: [1, 2, 3], key: 'key3' },
+          { data: { nested: { value: true } }, key: 'key4' }
+        ];
+
+        testCases.forEach(({ data, key }) => {
+          const encrypted1 = DyFM_Crypto.encrypt(data, key);
+          const encrypted2 = DyFM_Crypto.encrypt(data, key);
+          expect(encrypted1).toBe(encrypted2);
+        });
+      });
+    });
+
+    describe('| database persistence', () => {
+      interface UserData {
+        id: number;
+        name: string;
+        lastLogin: string;
+        preferences: {
+          language: string;
+          timezone: string;
+        };
+      }
+
+      it('| should successfully encrypt and decrypt data after database storage simulation', () => {
+        const originalData = {
+          id: 1,
+          name: 'test user',
+          email: 'test@example.com',
+          settings: {
+            theme: 'dark',
+            notifications: true
+          }
+        };
+        const key = 'db-storage-key';
+
+        // Simulate database storage and retrieval
+        const encrypted = DyFM_Crypto.encrypt(originalData, key);
+        const storedData = encrypted; // Simulating database storage
+        const retrievedData = storedData; // Simulating database retrieval
+        const decrypted = DyFM_Crypto.decrypt(retrievedData, key);
+
+        expect(decrypted).toEqual(originalData);
+      });
+
+      it('| should handle multiple encryption/decryption cycles for database operations', () => {
+        const userData: UserData = {
+          id: 1,
+          name: 'test user',
+          lastLogin: '2024-01-01T10:00:00.000Z',
+          preferences: {
+            language: 'en',
+            timezone: 'UTC'
+          }
+        };
+        const key = 'persistent-key';
+
+        // Simulate multiple database operations
+        const encrypted1 = DyFM_Crypto.encrypt(userData, key);
+        const decrypted1 = DyFM_Crypto.decrypt(encrypted1, key) as UserData;
+        
+        // Simulate data update with a different timestamp
+        const updatedData: UserData = { 
+          ...decrypted1, 
+          lastLogin: '2024-01-02T15:30:00.000Z'
+        };
+        const encrypted2 = DyFM_Crypto.encrypt(updatedData, key);
+        const decrypted2 = DyFM_Crypto.decrypt(encrypted2, key) as UserData;
+
+        expect(decrypted1).toEqual(userData);
+        expect(decrypted2).toEqual(updatedData);
+        expect(decrypted2.lastLogin).not.toBe(userData.lastLogin);
+      });
+
+      it('| should maintain data integrity through multiple database operations', () => {
+        const sensitiveData = {
+          id: 1,
+          password: 'hashed-password-123',
+          securityQuestions: [
+            { question: 'What is your pet name?', answer: 'Fluffy' },
+            { question: 'Where were you born?', answer: 'New York' }
+          ]
+        };
+        const key = 'sensitive-data-key';
+
+        // Simulate multiple database operations with the same data
+        const encrypted1 = DyFM_Crypto.encrypt(sensitiveData, key);
+        const decrypted1 = DyFM_Crypto.decrypt(encrypted1, key);
+        const encrypted2 = DyFM_Crypto.encrypt(decrypted1, key);
+        const decrypted2 = DyFM_Crypto.decrypt(encrypted2, key);
+
+        expect(decrypted1).toEqual(sensitiveData);
+        expect(decrypted2).toEqual(sensitiveData);
+        expect(encrypted1).toBe(encrypted2); // Different encryption instances
+      });
+    });
+
+    describe('| special characters', () => {
+      it('| should handle Unicode characters', () => {
+        const unicodeData = {
+          text: 'Hello 世界! 🌍',
+          emoji: '👋',
+          special: '!!!@@@###$$$%%%^^^&&&***((()))___+++---===[[[]]]{{{}}}|||;;;:::,,,...<<<>>>' +
+            'ĐĐĐđđđßßߤ¤¤×××÷÷÷¨¨¨¨~~~ˇˇˇ^^^˘˘˘°°°˛˛˛```˙˙˙´´´˝˝˝˝¸¸¸§§§' +
+            '???ééééáááűűűúúúőőőóóóüüüöööíííÉÉÉÁÁÁŰŰŰÚÚÚŐŐŐÓÓÓÜÖÖÖÍÍÍ'
+        };
+        const encrypted = DyFM_Crypto.encrypt(unicodeData, testKey);
+        const decrypted = DyFM_Crypto.decrypt(encrypted, testKey);
+        expect(decrypted).toEqual(unicodeData);
+      });
+
+      it('| should handle special characters in object keys', () => {
+        const specialKeyData = {
+          'key-with-spaces': 'value',
+          'key.with.dots': 'value',
+          'key-with-special-chars!@#': 'value',
+          'key-with-unicode-世界': 'value'
+        };
+        const encrypted = DyFM_Crypto.encrypt(specialKeyData, testKey);
+        const decrypted = DyFM_Crypto.decrypt(encrypted, testKey);
+        expect(decrypted).toEqual(specialKeyData);
+      });
+
+      it('| should handle special characters in nested objects', () => {
+        const nestedData = {
+          level1: {
+            'special-key!@#': {
+              'nested-key-世界': 'value with special chars!@#'
+            }
+          }
+        };
+        const encrypted = DyFM_Crypto.encrypt(nestedData, testKey);
+        const decrypted = DyFM_Crypto.decrypt(encrypted, testKey);
+        expect(decrypted).toEqual(nestedData);
+      });
+
+      it('| should handle special characters in arrays', () => {
+        const arrayData = [
+          'Hello 世界!',
+          { 'special-key': 'value with !@#' },
+          ['nested', 'array', 'with', 'special', 'chars!@#']
+        ];
+        const encrypted = DyFM_Crypto.encrypt(arrayData, testKey);
+        const decrypted = DyFM_Crypto.decrypt(encrypted, testKey);
+        expect(decrypted).toEqual(arrayData);
+      });
+    });
+
+    describe('| base64 padding and parsing edge cases', () => {
+      it('| should handle encrypted data missing 1 padding character', () => {
+        const encrypted = DyFM_Crypto.encrypt(testData, testKey);
+        // Remove last character (which might be padding)
+        const withoutPadding = encrypted.slice(0, -1);
+        expect(() => DyFM_Crypto.decrypt(withoutPadding, testKey)).toThrow();
+      });
+
+      it('| should handle encrypted data missing 2 padding characters', () => {
+        const encrypted = DyFM_Crypto.encrypt(testData, testKey);
+        // Remove last 2 characters
+        const withoutPadding = encrypted.slice(0, -2);
+        expect(() => DyFM_Crypto.decrypt(withoutPadding, testKey)).toThrow();
+      });
+
+      it('| should handle encrypted data missing 3 padding characters', () => {
+        const encrypted = DyFM_Crypto.encrypt(testData, testKey);
+        // Remove last 3 characters
+        const withoutPadding = encrypted.slice(0, -3);
+        expect(() => DyFM_Crypto.decrypt(withoutPadding, testKey)).toThrow();
+      });
+
+      it('| should detect base64 strings that are too short to be valid (less than 48 bytes)', () => {
+        // Create a minimal base64 string that parses to less than 48 bytes
+        // 18 bytes = 24 base64 characters (18 * 4/3 = 24)
+        const shortBase64 = 'ABCDEFGHIJKLMNOPQRSTUVW'; // 24 chars = 18 bytes when parsed
+        expect(() => DyFM_Crypto.decrypt(shortBase64, testKey)).toThrow();
+      });
+
+      it('| should handle base64 strings with incorrect padding', () => {
+        const encrypted = DyFM_Crypto.encrypt(testData, testKey);
+        // Add incorrect padding characters
+        const withIncorrectPadding = encrypted + '====';
+        expect(() => DyFM_Crypto.decrypt(withIncorrectPadding, testKey)).toThrow();
+      });
+
+      it('| should handle URL-safe base64 strings ending with dash', () => {
+        // Create a base64 string ending with '-' (which becomes '+' in regular base64)
+        const encrypted = DyFM_Crypto.encrypt(testData, testKey);
+        // Replace last character with dash if it's not already
+        const withDash = encrypted.slice(0, -1) + '-';
+        expect(() => DyFM_Crypto.decrypt(withDash, testKey)).toThrow();
+      });
+
+      it('| should handle URL-safe base64 strings ending with underscore', () => {
+        // Create a base64 string ending with '_' (which becomes '/' in regular base64)
+        const encrypted = DyFM_Crypto.encrypt(testData, testKey);
+        // Replace last character with underscore if it's not already
+        const withUnderscore = encrypted.slice(0, -1) + '_';
+        expect(() => DyFM_Crypto.decrypt(withUnderscore, testKey)).toThrow();
+      });
+
+      it('| should handle URL-safe base64 strings with no padding characters', () => {
+        const encrypted = DyFM_Crypto.encrypt(testData, testKey);
+        // Encrypted data should already have no padding (removed in encrypt method)
+        // This test verifies that decryption works without padding
+        expect(() => DyFM_Crypto.decrypt(encrypted, testKey)).not.toThrow();
+        const decrypted = DyFM_Crypto.decrypt(encrypted, testKey);
+        expect(decrypted).toEqual(testData);
+      });
+
+      it('| should handle very short base64 strings that parse to exactly 18 bytes', () => {
+        // Create a base64 string that parses to exactly 18 bytes
+        // 18 bytes = 24 base64 characters
+        const exactly18Bytes = 'ABCDEFGHIJKLMNOPQRSTUVWX'; // 24 chars
+        expect(() => DyFM_Crypto.decrypt(exactly18Bytes, testKey)).toThrow();
+      });
+
+      it('| should handle base64 strings that are valid format but too short after parsing', () => {
+        // Create a valid URL-safe base64 string that's too short
+        const validButShort = 'ABCDEFGHIJKLMNOPQRSTUVWXY'; // 25 chars, valid format
+        expect(() => DyFM_Crypto.decrypt(validButShort, testKey)).toThrow();
+      });
+    });
+  });
+
 });