Added more tests to cover edge cases and branches

Signed-off-by: Robert Gogete <gogeterobert@yahoo.com>

Author: gogeterobert

test/application/repositories/BlockRepository.test.ts

@@ -54,4 +54,10 @@ describe('BlockRepository', () => {
     expect(block5.hash.toString('hex')).toBe('e5'.padEnd(64, 'e'));
     await expect(repo.getBlockByHeight(999)).rejects.toThrow('Block with height 999 not found');
   });
+
+  it('should handle empty database gracefully', async () => {
+    const repo = new BlockRepository();
+    await expect(repo.getLatestBlock()).rejects.toThrow();
+    await expect(repo.getBlockByHeight(1)).rejects.toThrow();
+  });
 });

test/application/repositories/WalletRepository.test.ts

@@ -50,4 +50,15 @@ describe('WalletRepository', () => {
     walletRepo.addAddress('xch1234', 'name');
     expect(() => walletRepo.addAddress('xch1234', 'name')).toThrow('Wallet with this name already exists');
   });
+
+  it('should return undefined when getting a wallet that does not exist', () => {
+    const repo = new WalletRepository();
+    const wallets = repo.getAddresses();
+    expect(wallets.find(w => w.name === 'notfound')).toBeUndefined();
+  });
+
+  it('should not throw when removing a wallet that does not exist', () => {
+    const repo = new WalletRepository();
+    expect(() => repo.removeAddressByName('notfound')).not.toThrow();
+  });
 });

test/application/services/EncryptionService.test.ts

@@ -31,4 +31,18 @@ describe('EncryptionService', () => {
     const tampered = { ...encrypted, data: encrypted.data.slice(0, -1) + (encrypted.data.slice(-1) === '0' ? '1' : '0') };
     expect(() => EncryptionService.decryptData(tampered)).toThrow();
   });
+
+  it('should throw if decrypting with wrong salt', () => {
+    const data = EncryptionService.encryptData('secret');
+    // Tamper with salt
+    const tampered = { ...data, salt: 'ffffffffffffffffffffffffffffffff' };
+    expect(() => EncryptionService.decryptData(tampered)).toThrow();
+  });
+
+  it('should throw if decrypting with wrong nonce', () => {
+    const data = EncryptionService.encryptData('secret');
+    // Tamper with nonce
+    const tampered = { ...data, nonce: 'ffffffffffffffffffffffff' };
+    expect(() => EncryptionService.decryptData(tampered)).toThrow();
+  });
 });

test/application/services/WalletService.test.ts

@@ -118,14 +118,17 @@ describe('WalletService Integration', () => {
     await expect(WalletService.loadAddress('nonexistent')).rejects.toThrow('Address Not Found');
   });
 
-  it('should throw if address already exists when creating address', async () => {
-    const keyringPath = path.resolve('keyring.json');
-    await WalletService.createAddress('any');
-    // Ensure the file exists
-    await fs.ensureFile(keyringPath);
-    await expect(WalletService.createAddress('any')).rejects.toThrow('Address with the same name already exists.');
-    // Clean up
-    await fs.remove(keyringPath);
+
+  it('should throw if a wallet with the same name already exists in the keyring', async () => {
+    await WalletService.createAddress('duplicate');
+    await expect(WalletService.createAddress('duplicate')).rejects.toThrow('Address with the same name already exists.');
+  });
+
+  it('should allow creating different wallets even if keyring file exists', async () => {
+    await WalletService.createAddress('walletA');
+    // The keyring file now exists, but a different wallet name should succeed
+    const walletB = await WalletService.createAddress('walletB');
+    expect(walletB).toBeInstanceOf(Wallet);
   });
 
   describe('calculateFeeForCoinSpends', () => {
@@ -139,4 +142,31 @@ describe('WalletService Integration', () => {
       expect(fee).toBe(BigInt(1000000));
     });
   });
+
+  it('should return false when deleting a wallet that does not exist but keyring file exists', async () => {
+    await WalletService.createAddress('walletX');
+    const deleted = await WalletService.deleteAddress('nonexistent2');
+    expect(deleted).toBe(false);
+  });
+
+  it('should throw Address Not Found if keyring file exists but wallet name does not', async () => {
+    await WalletService.createAddress('walletY');
+    await expect(WalletService.loadAddress('notthere')).rejects.toThrow('Address Not Found');
+  });
+
+  it('should store and load the exact mnemonic if provided', async () => {
+    const mnemonic = 'test test test test test test test test test test test about';
+    await WalletService.createAddress('mnemonicTest', mnemonic);
+    const loaded = await WalletService.loadAddress('mnemonicTest');
+    expect(loaded.getMnemonic()).toBe(mnemonic);
+  });
+
+  it('should return empty array after deleting all wallets', async () => {
+    await WalletService.createAddress('del1');
+    await WalletService.createAddress('del2');
+    await WalletService.deleteAddress('del1');
+    await WalletService.deleteAddress('del2');
+    const wallets = WalletService.getAddresses();
+    expect(wallets).toEqual([]);
+  });
 });

test/application/types/ColdWallet.test.ts

@@ -58,4 +58,9 @@ describe('ColdWallet', () => {
     const result = await wallet.getBalances();
     expect(result).toEqual(expectedBalances);
   });
+
+  it('should throw if getPuzzleHash is called with invalid address', async () => {
+    const wallet = new ColdWallet('invalidaddress');
+    await expect(wallet.getPuzzleHash()).rejects.toThrow();
+  });
 });

test/application/types/Wallet.test.ts

@@ -1,4 +1,5 @@
-import config from "../../../src/config";
+import { Wallet } from '../../../src/application/types/Wallet';
+import config from '../../../src/config';
 
 describe('Wallet', () => {
   const TEST_MNEMONIC = 'test test test test test test test test test test test ball';
@@ -9,57 +10,61 @@ describe('Wallet', () => {
   });
 
   it('should return the mnemonic', () => {
-    wallet = new (require('../../../src/application/types/Wallet').Wallet)(TEST_MNEMONIC);
+    wallet = new Wallet(TEST_MNEMONIC);
     expect(wallet.getMnemonic()).toBe(TEST_MNEMONIC);
   });
 
-  it('should throw if mnemonic is missing', () => {
-    // purposely breaking for test
-    const w = new (require('../../../src/application/types/Wallet').Wallet)();
-    expect(() => w.getMnemonic()).toThrow('Mnemonic seed phrase is not loaded.');
-  });
-
   it('should return the expected master secret key', async () => {
-    wallet = new (require('../../../src/application/types/Wallet').Wallet)(TEST_MNEMONIC);
+    wallet = new Wallet(TEST_MNEMONIC);
     const key = await wallet.getMasterSecretKey();
-    expect(key.toString('hex')).toBe('3016401f710b4e57bc41a65ae853756c6bb87b91309ccd7cab7f9bf4aefd486b');
+    expect(key.toString('hex')).toBe(
+      '3016401f710b4e57bc41a65ae853756c6bb87b91309ccd7cab7f9bf4aefd486b',
+    );
   });
 
   it('should return the expected public synthetic key', async () => {
-    wallet = new (require('../../../src/application/types/Wallet').Wallet)(TEST_MNEMONIC);
+    wallet = new Wallet(TEST_MNEMONIC);
     const key = await wallet.getPublicSyntheticKey();
-    expect(key.toString('hex')).toBe('aa5b2a88de3885ada96bf2d4e3bde4385d4401f0fcc86326454e78651c755a597ce15d16e9570f4cd9b30d0a34f703a1');
+    expect(key.toString('hex')).toBe(
+      'aa5b2a88de3885ada96bf2d4e3bde4385d4401f0fcc86326454e78651c755a597ce15d16e9570f4cd9b30d0a34f703a1',
+    );
   });
 
   it('should return the expected private synthetic key', async () => {
-    wallet = new (require('../../../src/application/types/Wallet').Wallet)(TEST_MNEMONIC);
+    wallet = new Wallet(TEST_MNEMONIC);
     const key = await wallet.getPrivateSyntheticKey();
-    expect(key.toString('hex')).toBe('6b2f510ff5a9edafde155623bc19ba49f079d1b3c52443bb40dfc41ebcfff52b');
+    expect(key.toString('hex')).toBe(
+      '6b2f510ff5a9edafde155623bc19ba49f079d1b3c52443bb40dfc41ebcfff52b',
+    );
   });
 
   it('should return the expected owner puzzle hash', async () => {
-    wallet = new (require('../../../src/application/types/Wallet').Wallet)(TEST_MNEMONIC);
+    wallet = new Wallet(TEST_MNEMONIC);
     const hash = await wallet.getPuzzleHash();
-    expect(hash.toString('hex')).toBe('2485e1f2023ba59d36c63e2e52d3654d5d6a599773c82ba0895a3e74e7903550');
+    expect(hash.toString('hex')).toBe(
+      '2485e1f2023ba59d36c63e2e52d3654d5d6a599773c82ba0895a3e74e7903550',
+    );
   });
 
   it('should return the expected owner public key for mainet', async () => {
-    wallet = new (require('../../../src/application/types/Wallet').Wallet)(TEST_MNEMONIC);
+    wallet = new Wallet(TEST_MNEMONIC);
     config.BLOCKCHAIN_NETWORK = 'mainnet';
     const pub = await wallet.getOwnerPublicKey();
     expect(pub).toBe('xch1yjz7rusz8wje6dkx8ch995m9f4wk5kvhw0yzhgyftgl8feusx4gq820cf2');
   });
 
-    it('should return the expected owner public key for testnet', async () => {
-    wallet = new (require('../../../src/application/types/Wallet').Wallet)(TEST_MNEMONIC);
+  it('should return the expected owner public key for testnet', async () => {
+    wallet = new Wallet(TEST_MNEMONIC);
     config.BLOCKCHAIN_NETWORK = 'testnet';
     const pub = await wallet.getOwnerPublicKey();
     expect(pub).toBe('txch1yjz7rusz8wje6dkx8ch995m9f4wk5kvhw0yzhgyftgl8feusx4gq2dgwge');
   });
 
   it('should return the expected key ownership signature', async () => {
-    wallet = new (require('../../../src/application/types/Wallet').Wallet)(TEST_MNEMONIC);
+    wallet = new Wallet(TEST_MNEMONIC);
     const sig = await wallet.createKeyOwnershipSignature('nonce123');
-    expect(sig).toBe('a88c13c667ac01702e1629dc6aef9215239e4b1d09eb9533a43989850713e15444ff886c4d86f14841880c52ab3bffd90ebf63c2986b27ee0450dc04ee29aef9c01de29ec7d879d6d3fa269aaf8706894bdefa1fd09c03b4464ee7b2017703ee');
+    expect(sig).toBe(
+      'a88c13c667ac01702e1629dc6aef9215239e4b1d09eb9533a43989850713e15444ff886c4d86f14841880c52ab3bffd90ebf63c2986b27ee0450dc04ee29aef9c01de29ec7d879d6d3fa269aaf8706894bdefa1fd09c03b4464ee7b2017703ee',
+    );
   });
 });