reafactor: updated encryptionEngine tests to use bytes.fromHEX()

Author: AnonO6

tests/tests_encryptionEngine/test_generate.py

@@ -16,24 +16,35 @@ async def run_test():
             self.assertIn('masterKey', result)
             self.assertIn('keyShards', result)
 
-            # Check master key format (hex string with 0x prefix)
             self.assertIsInstance(result['masterKey'], str)
             self.assertTrue(result['masterKey'].startswith('0x'))
-            self.assertTrue(all(c in '0123456789abcdef' for c in result['masterKey'][2:]))
+            hex_str = result['masterKey'][2:]  
+            if len(hex_str) % 2 != 0:
+                hex_str = '0' + hex_str
+            try:
+                bytes.fromhex(hex_str)
+            except ValueError:
+                self.fail(f"Invalid hex string: {result['masterKey']}")
 
-            # Check key shards
             self.assertEqual(len(result['keyShards']), 3)
             for shard in result['keyShards']:
                 self.assertIn('key', shard)
                 self.assertIn('index', shard)
 
-                # Check key format (hex string with 0x prefix)
                 self.assertTrue(shard['key'].startswith('0x'))
-                self.assertTrue(all(c in '0123456789abcdef' for c in shard['key'][2:]))
+                hex_str = shard['key'][2:]  
+                if len(hex_str) % 2 != 0:
+                    hex_str = '0' + hex_str
+                try:
+                    bytes.fromhex(hex_str)
+                except ValueError:
+                    self.fail(f"Invalid hex string in key: {shard['key']}")
 
-                # Check index format (hex string with 0x prefix)
                 self.assertTrue(shard['index'].startswith('0x'))
-                self.assertTrue(all(c in '0123456789abcdef' for c in shard['index'][2:]))
+                try:
+                    int(shard['index'], 16)
+                except ValueError:
+                    self.fail(f"Invalid index format (not a valid hex number): {shard['index']}")
 
             return result
 
@@ -49,14 +60,26 @@ async def run_test():
 
             self.assertEqual(len(result['keyShards']), key_count)
 
-            # Check all indices are present and unique
             indices = [shard['index'] for shard in result['keyShards']]
-            self.assertEqual(len(set(indices)), key_count)  # All unique
+            self.assertEqual(len(set(indices)), key_count)  
 
-            # Verify all indices are valid hex strings with 0x prefix
-            for index in indices:
+            for shard in result['keyShards']:
+                self.assertTrue(shard['key'].startswith('0x'))
+                key_hex = shard['key'][2:]  
+                if len(key_hex) % 2 != 0:
+                    key_hex = '0' + key_hex
+                try:
+                    bytes.fromhex(key_hex)
+                except ValueError:
+                    self.fail(f"Invalid hex string in key: {shard['key']}")
+                
+                
+                index = shard['index']
                 self.assertTrue(index.startswith('0x'))
-                self.assertTrue(all(c in '0123456789abcdef' for c in index[2:]))
+                try:
+                    int(index, 16) 
+                except ValueError:
+                    self.fail(f"Invalid index format (not a valid hex number): {index}")
 
             return result
 

tests/tests_encryptionEngine/test_recover_key.py

@@ -29,6 +29,25 @@ async def run_test():
 
             shares = gen_result['keyShards'][:threshold]
             result = await EncryptionManager.recoverKey(shares)
+            self.assertTrue(result['masterKey'].startswith('0x'))
+            try:
+                bytes.fromhex(result['masterKey'][2:])
+            except ValueError:
+                self.fail(f"Invalid hex string in master key: {result['masterKey']}")
+            
+            for shard in shares:
+                self.assertTrue(shard['key'].startswith('0x'))
+                try:
+                    bytes.fromhex(shard['key'][2:])
+                except ValueError:
+                    self.fail(f"Invalid hex string in key: {shard['key']}")
+                
+                self.assertTrue(shard['index'].startswith('0x'))
+                try:
+                    bytes.fromhex(shard['index'][2:])
+                except ValueError:
+                    self.fail(f"Invalid hex string in index: {shard['index']}")
+            
             self.assertEqual(result['masterKey'], master_key)
             self.assertIsNone(result['error'])
 
@@ -67,12 +86,10 @@ async def run_test():
             key_count = 5
             gen_result = await EncryptionManager.generate(threshold=threshold, keyCount=key_count)
 
-            # Test with one less than threshold (should still work as long as we have at least 2 shares)
             result = await EncryptionManager.recoverKey(gen_result['keyShards'][:threshold-1])
             self.assertIsNotNone(result['masterKey'])
             self.assertIsNone(result['error'])
 
-            # Test with single share (should still work as long as we have at least 1 share)
             result = await EncryptionManager.recoverKey(gen_result['keyShards'][:1])
             self.assertIsNotNone(result['masterKey'])
             self.assertIsNone(result['error'])
@@ -137,6 +154,11 @@ async def run_test():
                 {'key': 'a' * 63, 'index': 'invalidindex'},
                 {'key': 'b' * 63, 'index': 'invalidindex2'}
             ])
+            self.assertTrue(result['masterKey'].startswith('0x'))
+            try:
+                bytes.fromhex(result['masterKey'][2:])
+            except ValueError:
+                self.fail(f"Invalid hex string in master key: {result['masterKey']}")
             self.assertIsNone(result['masterKey'])
             self.assertIn("invalid index format", result['error'].lower())