wallet-core: use testingWaitTransactionsFinal to wait for transactions

3 files changed, 116 insertions, 15 deletions

diff --git a/packages/taler-harness/src/harness/harness.ts b/packages/taler-harness/src/harness/harness.ts
index 7b2f980cc..1120eae84 100644
--- a/packages/taler-harness/src/harness/harness.ts
+++ b/packages/taler-harness/src/harness/harness.ts
@@ -41,17 +41,21 @@ import {
   Logger,
   MerchantReserveCreateConfirmation,
   MerchantTemplateAddDetails,
+  NotificationType,
   parsePaytoUri,
   stringToBytes,
   TalerError,
   TalerProtocolDuration,
+  TransactionMajorState,
   WalletNotification,
 } from "@gnu-taler/taler-util";
 import {
   BankApi,
   BankServiceHandle,
   HarnessExchangeBankAccount,
+  OpenedPromise,
   openPromise,
+  WalletApiOperation,
   WalletCoreApiClient,
   WalletCoreRequestType,
   WalletCoreResponseType,
@@ -934,7 +938,12 @@ export class FakebankService
     );
     await this.pingUntilAvailable();
     for (const acc of this.accounts) {
-      await BankApi.registerAccount(this, acc.accountName, acc.accountPassword, {});
+      await BankApi.registerAccount(
+        this,
+        acc.accountName,
+        acc.accountPassword,
+        {},
+      );
     }
   }
 
@@ -2246,9 +2255,26 @@ export interface WalletClientArgs {
   onNotification?(n: WalletNotification): void;
 }
 
+export type CancelFn = () => void;
+export type NotificationHandler = (n: WalletNotification) => void;
+
+/**
+ * Convenience wrapper around a (remote) wallet handle.
+ */
 export class WalletClient {
   remoteWallet: RemoteWallet | undefined = undefined;
   private waiter: WalletNotificationWaiter = makeNotificationWaiter();
+  notificationHandlers: NotificationHandler[] = [];
+
+  addNotificationListener(f: NotificationHandler): CancelFn {
+    this.notificationHandlers.push(f);
+    return () => {
+      const idx = this.notificationHandlers.indexOf(f);
+      if (idx >= 0) {
+        this.notificationHandlers.splice(idx, 1);
+      }
+    };
+  }
 
   async call<Op extends keyof WalletOperations>(
     operation: Op,
@@ -2260,6 +2286,7 @@ export class WalletClient {
     const client = getClientFromRemoteWallet(this.remoteWallet);
     return client.call(operation, payload);
   }
+
   constructor(private args: WalletClientArgs) {}
 
   async connect(): Promise<void> {
@@ -2272,6 +2299,9 @@ export class WalletClient {
           walletClient.args.onNotification(n);
         }
         waiter.notify(n);
+        for (const h of walletClient.notificationHandlers) {
+          h(n);
+        }
       },
     });
     this.remoteWallet = w;
diff --git a/packages/taler-harness/src/harness/helpers.ts b/packages/taler-harness/src/harness/helpers.ts
index fd6e9aa2e..8c62aef37 100644
--- a/packages/taler-harness/src/harness/helpers.ts
+++ b/packages/taler-harness/src/harness/helpers.ts
@@ -689,3 +689,73 @@ export async function makeTestPayment(
 
   t.assertTrue(orderStatus.order_status === "paid");
 }
+
+/**
+ * Make a simple payment and check that it succeeded.
+ */
+export async function makeTestPaymentV2(
+  t: GlobalTestState,
+  args: {
+    merchant: MerchantServiceInterface;
+    walletClient: WalletClient;
+    order: Partial<MerchantContractTerms>;
+    instance?: string;
+  },
+  auth: WithAuthorization = {},
+): Promise<void> {
+  // Set up order.
+
+  const { walletClient, merchant } = args;
+  const instance = args.instance ?? "default";
+
+  const orderResp = await MerchantPrivateApi.createOrder(
+    merchant,
+    instance,
+    {
+      order: args.order,
+    },
+    auth,
+  );
+
+  let orderStatus = await MerchantPrivateApi.queryPrivateOrderStatus(
+    merchant,
+    {
+      orderId: orderResp.order_id,
+    },
+    auth,
+  );
+
+  t.assertTrue(orderStatus.order_status === "unpaid");
+
+  // Make wallet pay for the order
+
+  const preparePayResult = await walletClient.call(
+    WalletApiOperation.PreparePayForUri,
+    {
+      talerPayUri: orderStatus.taler_pay_uri,
+    },
+  );
+
+  t.assertTrue(
+    preparePayResult.status === PreparePayResultType.PaymentPossible,
+  );
+
+  const r2 = await walletClient.call(WalletApiOperation.ConfirmPay, {
+    proposalId: preparePayResult.proposalId,
+  });
+
+  t.assertTrue(r2.type === ConfirmPayResultType.Done);
+
+  // Check if payment was successful.
+
+  orderStatus = await MerchantPrivateApi.queryPrivateOrderStatus(
+    merchant,
+    {
+      orderId: orderResp.order_id,
+      instance,
+    },
+    auth,
+  );
+
+  t.assertTrue(orderStatus.order_status === "paid");
+}
diff --git a/packages/taler-harness/src/integrationtests/test-payment.ts b/packages/taler-harness/src/integrationtests/test-payment.ts
index f184e57e7..9d1ce0e22 100644
--- a/packages/taler-harness/src/integrationtests/test-payment.ts
+++ b/packages/taler-harness/src/integrationtests/test-payment.ts
@@ -20,9 +20,9 @@
 import { WalletApiOperation } from "@gnu-taler/taler-wallet-core";
 import { GlobalTestState } from "../harness/harness.js";
 import {
-  createSimpleTestkudosEnvironment,
-  withdrawViaBank,
-  makeTestPayment,
+  createSimpleTestkudosEnvironmentV2,
+  withdrawViaBankV2,
+  makeTestPaymentV2,
 } from "../harness/helpers.js";
 import { j2s } from "@gnu-taler/taler-util";
 
@@ -32,12 +32,14 @@ import { j2s } from "@gnu-taler/taler-util";
 export async function runPaymentTest(t: GlobalTestState) {
   // Set up test environment
 
-  const { wallet, bank, exchange, merchant } =
-    await createSimpleTestkudosEnvironment(t);
+  const { walletClient, bank, exchange, merchant } =
+    await createSimpleTestkudosEnvironmentV2(t);
 
   // Withdraw digital cash into the wallet.
 
-  await withdrawViaBank(t, { wallet, bank, exchange, amount: "TESTKUDOS:20" });
+  await withdrawViaBankV2(t, { walletClient, bank, exchange, amount: "TESTKUDOS:20" });
+
+  await walletClient.call(WalletApiOperation.TestingWaitTransactionsFinal, {});
 
   const order = {
     summary: "Buy me!",
@@ -45,8 +47,8 @@ export async function runPaymentTest(t: GlobalTestState) {
     fulfillment_url: "taler://fulfillment-success/thx",
   };
 
-  await makeTestPayment(t, { wallet, merchant, order });
-  await wallet.runUntilDone();
+  await makeTestPaymentV2(t, { walletClient, merchant, order });
+  await walletClient.call(WalletApiOperation.TestingWaitTransactionsFinal, {});
 
   // Test JSON normalization of contract terms: Does the wallet
   // agree with the merchant?
@@ -56,8 +58,8 @@ export async function runPaymentTest(t: GlobalTestState) {
     fulfillment_url: "taler://fulfillment-success/thx",
   };
 
-  await makeTestPayment(t, { wallet, merchant, order: order2 });
-  await wallet.runUntilDone();
+  await makeTestPaymentV2(t, { walletClient, merchant, order: order2 });
+  await walletClient.call(WalletApiOperation.TestingWaitTransactionsFinal, {});
 
   // Test JSON normalization of contract terms: Does the wallet
   // agree with the merchant?
@@ -67,11 +69,10 @@ export async function runPaymentTest(t: GlobalTestState) {
     fulfillment_url: "taler://fulfillment-success/thx",
   };
 
-  await makeTestPayment(t, { wallet, merchant, order: order3 });
-
-  await wallet.runUntilDone();
+  await makeTestPaymentV2(t, { walletClient, merchant, order: order3 });
+  await walletClient.call(WalletApiOperation.TestingWaitTransactionsFinal, {});
 
-  const bal = await wallet.client.call(WalletApiOperation.GetBalances, {});
+  const bal = await walletClient.call(WalletApiOperation.GetBalances, {});
   console.log(`balance after 3 payments: ${j2s(bal)}`);
   t.assertAmountEquals(bal.balances[0].available, "TESTKUDOS:3.8");
   t.assertAmountEquals(bal.balances[0].pendingIncoming, "TESTKUDOS:0");