e2e test for credential import

Author: m-parkhill

apps/wallet-server/jest.setup.js

@@ -7,3 +7,15 @@ jest.mock('@docknetwork/wallet-sdk-wasm/src/services/blockchain', () => ({
     isBlockchainReady: true,
   },
 }));
+
+// The wallet SDK can emit late debug logs from background status updates.
+// Keep integration tests deterministic by silencing data-store logger output.
+jest.mock('@docknetwork/wallet-sdk-data-store/src/logger', () => ({
+  logger: {
+    debug: jest.fn(),
+    performance: jest.fn(),
+    error: jest.fn(),
+    warn: jest.fn(),
+    info: jest.fn(),
+  },
+}));

apps/wallet-server/src/features/credentials/tests/integration/credentials-client.test.ts

@@ -7,10 +7,15 @@ import { describe, it, expect, beforeEach, afterEach } from "@jest/globals";
 
 import { WalletClient } from "../../../../wallet-client";
 import { CredentialClient } from "../../client";
+import { DIDClient } from "../../../dids/client";
+
+const OID4VCI_TEST_OFFER_URI =
+  "openid-credential-offer://?credential_offer_uri=https://api-testnet.truvera.io/openid/credential-offers/fbe0a6ed-2aa8-4363-833b-6aa8fe1c6d01";
 
 describe("integration: CredentialClient with real Wallet SDK", () => {
   let walletClient: WalletClient;
   let credentialClient: CredentialClient;
+  let didClient: DIDClient;
 
   beforeEach(async () => {
     // Create a unique wallet for each test to avoid conflicts
@@ -20,19 +25,23 @@ describe("integration: CredentialClient with real Wallet SDK", () => {
     // Initialize wallet and credential client
     const wallet = await walletClient.initialize();
     credentialClient = new CredentialClient(wallet);
+    didClient = new DIDClient(wallet);
   });
 
   afterEach(async () => {
+    if (walletClient) {
+      await walletClient.waitForIdle();
+    }
+
     // Clean up wallet resources after each test
     if (walletClient && walletClient.isInitialized()) {
       try {
         await walletClient.deleteWallet();
+        await walletClient.waitForIdle();
       } catch (error) {
         console.error("Error cleaning up wallet:", error);
       }
     }
-    // Wait for remaining async operations to complete
-    await new Promise((resolve) => setTimeout(resolve, 100));
   });
 
   describe("listCredentials", () => {
@@ -133,5 +142,34 @@ describe("integration: CredentialClient with real Wallet SDK", () => {
       // message is present on failure
       expect(result).toHaveProperty("message");
     });
+
+    it("imports credential from OID4VCI offer URL and stores it in the wallet SDK", async () => {
+      // Ensure the wallet has a DID available before import.
+      await didClient.createDID();
+
+      const before = await credentialClient.listCredentials();
+
+      const importResult = await credentialClient.importCredential(OID4VCI_TEST_OFFER_URI);
+      expect(importResult.success).toBe(true);
+      expect(importResult.credential).toBeDefined();
+
+      const after = await credentialClient.listCredentials();
+      expect(after.count).toBeGreaterThan(before.count);
+
+      // Verify the imported credential is visible via wallet-sdk provider storage too.
+      const { createCredentialProvider } = await import("@docknetwork/wallet-sdk-core/lib/credential-provider.js");
+      const provider = createCredentialProvider({ wallet: walletClient.getWallet() });
+      const sdkCredentials = await provider.getCredentials();
+      expect(sdkCredentials.length).toBeGreaterThan(0);
+
+      const importedId = importResult.credential?.id;
+      if (importedId) {
+        const inSdkStore = sdkCredentials.some((doc: any) => {
+          const id = doc?.id || doc?.credential?.id;
+          return id === importedId;
+        });
+        expect(inSdkStore).toBe(true);
+      }
+    });
   });
 });

apps/wallet-server/src/features/dids/tests/integration/dids-client.test.ts

@@ -23,6 +23,10 @@ describe("integration: DIDClient with real Wallet SDK", () => {
   });
 
   afterEach(async () => {
+    if (walletClient) {
+      await walletClient.waitForIdle();
+    }
+
     // Clean up wallet resources after each test
     if (walletClient && walletClient.isInitialized()) {
       try {
@@ -31,8 +35,6 @@ describe("integration: DIDClient with real Wallet SDK", () => {
         console.error("Error cleaning up wallet:", error);
       }
     }
-    // Wait for remaining async operations to complete
-    await new Promise((resolve) => setTimeout(resolve, 100));
   });
 
   describe("getDefaultDID", () => {

apps/wallet-server/src/wallet-client.ts

@@ -45,12 +45,64 @@ export class WalletClient {
   private walletName: string;
   private networkId: string;
   private dataStore: DataStore | null = null;
+  private inFlightDocumentOps = 0;
+  private idleWaiters: Array<() => void> = [];
 
   constructor(walletName: string = "default-wallet", networkId: string = "testnet") {
     this.walletName = walletName;
     this.networkId = networkId;
   }
 
+  private trackDocumentOperation<T>(operation: Promise<T>): Promise<T> {
+    this.inFlightDocumentOps += 1;
+
+    return operation.finally(() => {
+      this.inFlightDocumentOps = Math.max(0, this.inFlightDocumentOps - 1);
+
+      if (this.inFlightDocumentOps === 0) {
+        const waiters = this.idleWaiters.splice(0);
+        for (const resolve of waiters) {
+          resolve();
+        }
+      }
+    });
+  }
+
+  /**
+   * Wait until tracked document operations settle.
+   * This avoids brittle fixed sleeps in integration tests.
+   */
+  async waitForIdle(timeoutMs: number = 10000): Promise<void> {
+    const start = Date.now();
+
+    while (true) {
+      if (this.inFlightDocumentOps === 0) {
+        // Ensure no new operations were queued in the same tick.
+        await new Promise<void>((resolve) => setImmediate(resolve));
+        if (this.inFlightDocumentOps === 0) {
+          return;
+        }
+      }
+
+      const elapsed = Date.now() - start;
+      const remaining = timeoutMs - elapsed;
+      if (remaining <= 0) {
+        throw new Error(`Timed out waiting for wallet document operations to settle after ${timeoutMs}ms`);
+      }
+
+      await new Promise<void>((resolve, reject) => {
+        const timeoutId = setTimeout(() => {
+          reject(new Error(`Timed out waiting for wallet document operations to settle after ${timeoutMs}ms`));
+        }, remaining);
+
+        this.idleWaiters.push(() => {
+          clearTimeout(timeoutId);
+          resolve();
+        });
+      });
+    }
+  }
+
   /**
    * Initialize the wallet
    */
@@ -75,14 +127,14 @@ export class WalletClient {
       },
       dataSource,
       documentStore: {
-        addDocument: (json, options) => createDocument({ dataStore, json, options }),
-        removeDocument: (id, options) => removeDocument({ dataStore, id, options }),
-        updateDocument: (document, options) => updateDocument({ dataStore, document, options }),
+        addDocument: (json, options) => this.trackDocumentOperation(createDocument({ dataStore, json, options })),
+        removeDocument: (id, options) => this.trackDocumentOperation(removeDocument({ dataStore, id, options })),
+        updateDocument: (document, options) => this.trackDocumentOperation(updateDocument({ dataStore, document, options })),
         getDocumentById: (id) => getDocumentById({ dataStore, id }),
         getDocumentsByType: (type) => getDocumentsByType({ dataStore, type }),
         getDocumentsById: (idList) => getDocumentsById({ dataStore, idList }),
         getAllDocuments: (allNetworks) => getAllDocuments({ dataStore, allNetworks }),
-        removeAllDocuments: () => removeAllDocuments({ dataStore }),
+        removeAllDocuments: () => this.trackDocumentOperation(removeAllDocuments({ dataStore })),
         getDocumentCorrelations: (documentId) => getDocumentCorrelations({ dataStore, documentId }),
       },
       localStorageImpl,
@@ -161,14 +213,13 @@ export class WalletClient {
 
       // Call wallet cleanup
       try {
+        await this.waitForIdle();
         await this.wallet.deleteWallet();
+        await this.waitForIdle();
       } catch (err) {
         console.debug("Error in wallet.deleteWallet():", err);
       }
 
-      // Wait for async operations to settle before cleanup
-      await new Promise((resolve) => setTimeout(resolve, 100));
-
       // Null out references to allow garbage collection
       this.wallet = null;
       this.dataStore = null;