test(core-transaction-pool): add more tests for getTransactionsForForging

__tests__/helpers/transaction-factory.ts

@@ -193,7 +193,6 @@ export class TransactionFactory {
         Managers.configManager.setFromPreset(this.network);
 
         const transactions: T[] = [];
-
         for (let i = 0; i < quantity; i++) {
             if (this.builder.constructor.name === "TransferBuilder") {
                 // @FIXME: when we use any of the "withPassphrase*" methods the builder will

__tests__/integration/core-api/v2/handlers/transactions.test.ts

@@ -557,8 +557,8 @@ describe("API 2.0 - Transactions", () => {
         it.each([3, 5, 8])("should accept and broadcast %i transactions emptying a wallet", async txNumber => {
             const sender = delegates[txNumber]; // use txNumber so that we use a different delegate for each test case
             const receivers = generateWallets("testnet", 2);
-            const amountPlusFee = Math.floor(sender.balance / txNumber);
-            const lastAmountPlusFee = sender.balance - (txNumber - 1) * amountPlusFee;
+            const amountPlusFee = Math.floor(+sender.balance / txNumber);
+            const lastAmountPlusFee = +sender.balance - (txNumber - 1) * amountPlusFee;
 
             const transactions = TransactionFactory.transfer(receivers[0].address, amountPlusFee - transferFee)
                 .withNetwork("testnet")
@@ -591,8 +591,8 @@ describe("API 2.0 - Transactions", () => {
             async txNumber => {
                 const sender = delegates[txNumber + 1]; // use txNumber + 1 so that we don't use the same delegates as the above test
                 const receivers = generateWallets("testnet", 2);
-                const amountPlusFee = Math.floor(sender.balance / txNumber);
-                const lastAmountPlusFee = sender.balance - (txNumber - 1) * amountPlusFee + 1;
+                const amountPlusFee = Math.floor(+sender.balance / txNumber);
+                const lastAmountPlusFee = +sender.balance - (txNumber - 1) * amountPlusFee + 1;
 
                 const transactions = TransactionFactory.transfer(receivers[0].address, amountPlusFee - transferFee)
                     .withNetwork("testnet")

__tests__/integration/core-blockchain/blockchain.test.ts

@@ -55,6 +55,14 @@ const addBlocks = async untilHeight => {
     }
 };
 
+const indexWalletWithSufficientBalance = (transaction: Interfaces.ITransaction): void => {
+    const walletManager = blockchain.database.walletManager;
+
+    const wallet = walletManager.findByPublicKey(transaction.data.senderPublicKey);
+    wallet.balance = wallet.balance.abs().plus(transaction.data.amount.plus(transaction.data.fee));
+    walletManager.reindex(wallet);
+};
+
 describe("Blockchain", () => {
     beforeAll(async () => {
         container = await setUp();
@@ -91,19 +99,25 @@ describe("Blockchain", () => {
 
     describe("postTransactions", () => {
         it("should be ok", async () => {
-            const transactionsWithoutType2 = genesisBlock.transactions.filter(tx => tx.type !== 2);
-
             blockchain.transactionPool.flush();
-            await blockchain.postTransactions(transactionsWithoutType2);
-            const transactions = blockchain.transactionPool.getTransactions(0, 200);
 
-            expect(transactions.length).toBe(transactionsWithoutType2.length);
+            jest.spyOn(blockchain.transactionPool as any, "removeForgedTransactions").mockReturnValue([]);
 
-            expect(transactions).toIncludeAllMembers(
-                transactionsWithoutType2.map(transaction => transaction.serialized),
-            );
+            for (const transaction of genesisBlock.transactions) {
+                indexWalletWithSufficientBalance(transaction);
+            }
+
+            const transferTransactions = genesisBlock.transactions.filter(tx => tx.type === 0);
+
+            await blockchain.postTransactions(transferTransactions);
+            const transactions = await blockchain.transactionPool.getTransactions(0, 200);
+
+            expect(transactions.length).toBe(transferTransactions.length);
+
+            expect(transactions).toIncludeAllMembers(transferTransactions.map(transaction => transaction.serialized));
 
             blockchain.transactionPool.flush();
+            jest.restoreAllMocks();
         });
     });
 

__tests__/unit/core-p2p/socket-server/versions/internal/handlers/transactions.test.ts

@@ -8,11 +8,11 @@ jest.mock("../../../../../../../packages/core-p2p/src/socket-server/utils/valida
 
 describe("Internal handlers - transactions", () => {
     describe("getUnconfirmedTransactions", () => {
-        it("should return unconfirmed transactions", () => {
+        it("should return unconfirmed transactions", async () => {
             transactionPool.getTransactionsForForging = jest.fn().mockReturnValue(["111"]);
             transactionPool.getPoolSize = jest.fn().mockReturnValue(1);
 
-            expect(getUnconfirmedTransactions()).toEqual({ poolSize: 1, transactions: ["111"] });
+            expect(await getUnconfirmedTransactions()).toEqual({ poolSize: 1, transactions: ["111"] });
         });
     });
 });

__tests__/unit/core-transaction-pool/__stubs__/connection.ts

@@ -70,23 +70,19 @@ export class Connection implements TransactionPool.IConnection {
         return;
     }
 
-    public getTransactionsForForging(blockSize: number): string[] {
+    public async getTransactionsForForging(blockSize: number): Promise<string[]> {
         return [];
     }
 
     public getTransaction(id: string): Interfaces.ITransaction {
         return undefined;
     }
 
-    public getTransactions(start: number, size: number, maxBytes?: number): Buffer[] {
+    public async getTransactions(start: number, size: number, maxBytes?: number): Promise<Buffer[]> {
         return [];
     }
 
-    public getTransactionIdsForForging(start: number, size: number): string[] {
-        return undefined;
-    }
-
-    public getTransactionsData(start: number, size: number, maxBytes?: number): Interfaces.ITransaction[] {
+    public async getTransactionIdsForForging(start: number, size: number): Promise<string[]> {
         return undefined;
     }