From 6915c979a20e8a7ac80ff41493ef8203d6b2e616 Mon Sep 17 00:00:00 2001
From: Alex Lewin <43247027+alexlwn123@users.noreply.github.com>
Date: Mon, 30 Sep 2024 18:03:04 -0400
Subject: [PATCH] Feat: adds testing fixtures for setup/teardown (#51)

* feat: disable screenshots on failed tests

* feat: add worker unit tests
---
 docs/examples/vite-react.md                   |   1 +
 examples/bare-js/index.html                   |   3 +
 .../src/services/FederationService.test.ts    | 128 ++++++------
 .../src/services/LightningService.test.ts     | 190 ++++++++----------
 packages/core-web/src/test/TestingService.ts  |   6 +-
 packages/core-web/src/test/setupTests.ts      |  43 ++++
 packages/core-web/src/worker/worker.js        |   3 +
 packages/core-web/src/worker/worker.test.ts   |  93 +++++++++
 vitest.workspace.ts                           |   1 +
 9 files changed, 295 insertions(+), 173 deletions(-)
 create mode 100644 packages/core-web/src/test/setupTests.ts
 create mode 100644 packages/core-web/src/worker/worker.test.ts
diff --git a/docs/examples/vite-react.md b/docs/examples/vite-react.md
index 2f3ab96..b755d98 100644
--- a/docs/examples/vite-react.md
+++ b/docs/examples/vite-react.md
@@ -15,6 +15,7 @@ You might need to disable your adblocker or Brave Shields to see the preview.
 :::
 
 <iframe src="https://stackblitz.com/github/fedimint/fedimint-web-sdk/tree/main/examples/vite-core?embed=1&file=src%2FApp.tsx" style="width: 100%; height: 600px; border: 0;"></iframe>
+
 [![Open in StackBlitz](https://developer.stackblitz.com/img/open_in_stackblitz.svg)](https://stackblitz.com/github/fedimint/fedimint-web-sdk/tree/main/examples/vite-core)
 
 ## Running the Example Locally
diff --git a/examples/bare-js/index.html b/examples/bare-js/index.html
index e18a6b4..60b0dbb 100644
--- a/examples/bare-js/index.html
+++ b/examples/bare-js/index.html
@@ -8,6 +8,7 @@
   </head>
 
 <body>
+  <!-- UI Code -->
   <div class="container">
     <h2>Fedimint Web SDK Bare html/js example</h2>
     <div id="actions">
@@ -18,7 +19,9 @@ <h2>Fedimint Web SDK Bare html/js example</h2>
     <div id="console"></div>
     <p>Faucet Link: <a href="https://faucet.mutinynet.com/" target="_blank">https://faucet.mutinynet.com/</a></p>
   </div>
+
   <script type="module">
+    // Import the @fedimint/core-web library
     import * as Default from './index.js';
     const { FedimintWallet } = Default;
 
diff --git a/packages/core-web/src/services/FederationService.test.ts b/packages/core-web/src/services/FederationService.test.ts
index 33986be..d46ad5c 100644
--- a/packages/core-web/src/services/FederationService.test.ts
+++ b/packages/core-web/src/services/FederationService.test.ts
@@ -1,70 +1,58 @@
-import { test, expect } from 'vitest'
-import { TestFedimintWallet } from '../test/TestFedimintWallet'
-import { beforeAll } from 'vitest'
-
-let randomTestingId: string
-let wallet: TestFedimintWallet
-
-beforeAll(async () => {
-  randomTestingId = Math.random().toString(36).substring(2, 15)
-  wallet = new TestFedimintWallet()
-  expect(wallet).toBeDefined()
-  await expect(
-    wallet.joinFederation(wallet.testing.TESTING_INVITE, randomTestingId),
-  ).resolves.toBeUndefined()
-  expect(wallet.isOpen()).toBe(true)
-
-  // Cleanup after all tests
-  return async () => {
-    // clear up browser resources
-    await wallet.cleanup()
-    // remove the wallet db
-    indexedDB.deleteDatabase(randomTestingId)
-    // swap out the randomTestingId for a new one, to avoid raciness
-    randomTestingId = Math.random().toString(36).substring(2, 15)
-  }
-})
-
-test('getConfig should return the federation config', async () => {
-  expect(wallet).toBeDefined()
-  expect(wallet.isOpen()).toBe(true)
-  const counterBefore = wallet.testing.getRequestCounter()
-  await expect(wallet.federation.getConfig()).resolves.toMatchObject({
-    api_endpoints: expect.any(Object),
-    broadcast_public_keys: expect.any(Object),
-    consensus_version: expect.any(Object),
-    meta: expect.any(Object),
-    modules: expect.any(Object),
-  })
-  expect(wallet.testing.getRequestCounter()).toBe(counterBefore + 1)
-})
-
-test('getFederationId should return the federation id', async () => {
-  expect(wallet).toBeDefined()
-  expect(wallet.isOpen()).toBe(true)
-
-  const counterBefore = wallet.testing.getRequestCounter()
-  const federationId = await wallet.federation.getFederationId()
-  expect(federationId).toBeTypeOf('string')
-  expect(federationId).toHaveLength(64)
-  expect(wallet.testing.getRequestCounter()).toBe(counterBefore + 1)
-})
-
-test('getInviteCode should return the invite code', async () => {
-  expect(wallet).toBeDefined()
-  expect(wallet.isOpen()).toBe(true)
-
-  const counterBefore = wallet.testing.getRequestCounter()
-  const inviteCode = await wallet.federation.getInviteCode(0)
-  expect(inviteCode).toBeTypeOf('string')
-  expect(wallet.testing.getRequestCounter()).toBe(counterBefore + 1)
-})
-
-test('listOperations should return the list of operations', async () => {
-  expect(wallet).toBeDefined()
-  expect(wallet.isOpen()).toBe(true)
-
-  const counterBefore = wallet.testing.getRequestCounter()
-  await expect(wallet.federation.listOperations()).resolves.toMatchObject([])
-  expect(wallet.testing.getRequestCounter()).toBe(counterBefore + 1)
-})
+import { expect } from 'vitest'
+import { walletTest } from '../test/setupTests'
+
+walletTest(
+  'getConfig should return the federation config',
+  async ({ wallet }) => {
+    expect(wallet).toBeDefined()
+    expect(wallet.isOpen()).toBe(true)
+    const counterBefore = wallet.testing.getRequestCounter()
+    await expect(wallet.federation.getConfig()).resolves.toMatchObject({
+      api_endpoints: expect.any(Object),
+      broadcast_public_keys: expect.any(Object),
+      consensus_version: expect.any(Object),
+      meta: expect.any(Object),
+      modules: expect.any(Object),
+    })
+    expect(wallet.testing.getRequestCounter()).toBe(counterBefore + 1)
+  },
+)
+
+walletTest(
+  'getFederationId should return the federation id',
+  async ({ wallet }) => {
+    expect(wallet).toBeDefined()
+    expect(wallet.isOpen()).toBe(true)
+
+    const counterBefore = wallet.testing.getRequestCounter()
+    const federationId = await wallet.federation.getFederationId()
+    expect(federationId).toBeTypeOf('string')
+    expect(federationId).toHaveLength(64)
+    expect(wallet.testing.getRequestCounter()).toBe(counterBefore + 1)
+  },
+)
+
+walletTest(
+  'getInviteCode should return the invite code',
+  async ({ wallet }) => {
+    expect(wallet).toBeDefined()
+    expect(wallet.isOpen()).toBe(true)
+
+    const counterBefore = wallet.testing.getRequestCounter()
+    const inviteCode = await wallet.federation.getInviteCode(0)
+    expect(inviteCode).toBeTypeOf('string')
+    expect(wallet.testing.getRequestCounter()).toBe(counterBefore + 1)
+  },
+)
+
+walletTest(
+  'listOperations should return the list of operations',
+  async ({ wallet }) => {
+    expect(wallet).toBeDefined()
+    expect(wallet.isOpen()).toBe(true)
+
+    const counterBefore = wallet.testing.getRequestCounter()
+    await expect(wallet.federation.listOperations()).resolves.toMatchObject([])
+    expect(wallet.testing.getRequestCounter()).toBe(counterBefore + 1)
+  },
+)
diff --git a/packages/core-web/src/services/LightningService.test.ts b/packages/core-web/src/services/LightningService.test.ts
index 3e9b7aa..8bde236 100644
--- a/packages/core-web/src/services/LightningService.test.ts
+++ b/packages/core-web/src/services/LightningService.test.ts
@@ -1,76 +1,61 @@
-import { test, expect } from 'vitest'
-import { TestFedimintWallet } from '../test/TestFedimintWallet'
-import { beforeAll } from 'vitest'
-
-let randomTestingId: string
-let wallet: TestFedimintWallet
-
-beforeAll(async () => {
-  randomTestingId = Math.random().toString(36).substring(2, 15)
-  wallet = new TestFedimintWallet()
-  expect(wallet).toBeDefined()
-  await expect(
-    wallet.joinFederation(wallet.testing.TESTING_INVITE, randomTestingId),
-  ).resolves.toBeUndefined()
-  expect(wallet.isOpen()).toBe(true)
-
-  // Cleanup after all tests
-  return async () => {
-    // clear up browser resources
-    await wallet.cleanup()
-    // remove the wallet db
-    indexedDB.deleteDatabase(randomTestingId)
-    // swap out the randomTestingId for a new one, to avoid raciness
-    randomTestingId = Math.random().toString(36).substring(2, 15)
-  }
-})
-
-test('createInvoice should create a bolt11 invoice', async () => {
-  expect(wallet).toBeDefined()
-  expect(wallet.isOpen()).toBe(true)
-
-  const counterBefore = wallet.testing.getRequestCounter()
-  const invoice = await wallet.lightning.createInvoice(100, 'test')
-  expect(invoice).toBeDefined()
-  expect(invoice).toMatchObject({
-    invoice: expect.any(String),
-    operation_id: expect.any(String),
-  })
-  // 3 requests were made, one for the invoice, one for refreshing the
-  // gateway cache, one for getting the gateway info
-  expect(wallet.testing.getRequestCounter()).toBe(counterBefore + 3)
-
-  // Test with expiry time
-  await expect(
-    wallet.lightning.createInvoice(100, 'test', 1000, {}),
-  ).resolves.toBeDefined()
-})
-
-test('listGateways should return a list of gateways', async () => {
-  expect(wallet).toBeDefined()
-  expect(wallet.isOpen()).toBe(true)
-
-  const counterBefore = wallet.testing.getRequestCounter()
-  const gateways = await wallet.lightning.listGateways()
-  expect(wallet.testing.getRequestCounter()).toBe(counterBefore + 1)
-  expect(gateways).toBeDefined()
-  expect(gateways).toMatchObject([
-    {
-      info: expect.any(Object),
-    },
-  ])
-})
-
-test('updateGatewayCache should update the gateway cache', async () => {
-  expect(wallet).toBeDefined()
-  expect(wallet.isOpen()).toBe(true)
-
-  const counterBefore = wallet.testing.getRequestCounter()
-  await expect(wallet.lightning.updateGatewayCache()).resolves.toBeDefined()
-  expect(wallet.testing.getRequestCounter()).toBe(counterBefore + 1)
-})
-
-test('getGateway should return a gateway', async () => {
+import { expect } from 'vitest'
+import { walletTest } from '../test/setupTests'
+
+walletTest(
+  'createInvoice should create a bolt11 invoice',
+  async ({ wallet }) => {
+    expect(wallet).toBeDefined()
+    expect(wallet.isOpen()).toBe(true)
+
+    const counterBefore = wallet.testing.getRequestCounter()
+    const invoice = await wallet.lightning.createInvoice(100, 'test')
+    expect(invoice).toBeDefined()
+    expect(invoice).toMatchObject({
+      invoice: expect.any(String),
+      operation_id: expect.any(String),
+    })
+    // 3 requests were made, one for the invoice, one for refreshing the
+    // gateway cache, one for getting the gateway info
+    expect(wallet.testing.getRequestCounter()).toBe(counterBefore + 3)
+
+    // Test with expiry time
+    await expect(
+      wallet.lightning.createInvoice(100, 'test', 1000, {}),
+    ).resolves.toBeDefined()
+  },
+)
+
+walletTest(
+  'listGateways should return a list of gateways',
+  async ({ wallet }) => {
+    expect(wallet).toBeDefined()
+    expect(wallet.isOpen()).toBe(true)
+
+    const counterBefore = wallet.testing.getRequestCounter()
+    const gateways = await wallet.lightning.listGateways()
+    expect(wallet.testing.getRequestCounter()).toBe(counterBefore + 1)
+    expect(gateways).toBeDefined()
+    expect(gateways).toMatchObject([
+      {
+        info: expect.any(Object),
+      },
+    ])
+  },
+)
+
+walletTest(
+  'updateGatewayCache should update the gateway cache',
+  async ({ wallet }) => {
+    expect(wallet).toBeDefined()
+    expect(wallet.isOpen()).toBe(true)
+
+    const counterBefore = wallet.testing.getRequestCounter()
+    await expect(wallet.lightning.updateGatewayCache()).resolves.toBeDefined()
+    expect(wallet.testing.getRequestCounter()).toBe(counterBefore + 1)
+  },
+)
+
+walletTest('getGateway should return a gateway', async ({ wallet }) => {
   expect(wallet).toBeDefined()
   expect(wallet.isOpen()).toBe(true)
 
@@ -89,40 +74,43 @@ test('getGateway should return a gateway', async () => {
   })
 })
 
-test('createInvoiceWithGateway should create a bolt11 invoice with a gateway', async () => {
-  expect(wallet).toBeDefined()
-  expect(wallet.isOpen()).toBe(true)
+walletTest(
+  'createInvoiceWithGateway should create a bolt11 invoice with a gateway',
+  async ({ wallet }) => {
+    expect(wallet).toBeDefined()
+    expect(wallet.isOpen()).toBe(true)
 
-  const gateways = await wallet.lightning.listGateways()
-  const gateway = gateways[0]
-  expect(gateway).toBeDefined()
+    const gateways = await wallet.lightning.listGateways()
+    const gateway = gateways[0]
+    expect(gateway).toBeDefined()
 
-  const counterBefore = wallet.testing.getRequestCounter()
-  const invoice = await wallet.lightning.createInvoiceWithGateway(
-    100,
-    'test',
-    null,
-    {},
-    gateway.info,
-  )
-  expect(invoice).toBeDefined()
-  expect(invoice).toMatchObject({
-    invoice: expect.any(String),
-    operation_id: expect.any(String),
-  })
-  expect(wallet.testing.getRequestCounter()).toBe(counterBefore + 1)
-  await expect(
-    wallet.lightning.createInvoiceWithGateway(
+    const counterBefore = wallet.testing.getRequestCounter()
+    const invoice = await wallet.lightning.createInvoiceWithGateway(
       100,
       'test',
-      1000,
+      null,
       {},
       gateway.info,
-    ),
-  ).resolves.toBeDefined()
-})
-
-test('payInvoice should pay a bolt11 invoice', async () => {
+    )
+    expect(invoice).toBeDefined()
+    expect(invoice).toMatchObject({
+      invoice: expect.any(String),
+      operation_id: expect.any(String),
+    })
+    expect(wallet.testing.getRequestCounter()).toBe(counterBefore + 1)
+    await expect(
+      wallet.lightning.createInvoiceWithGateway(
+        100,
+        'test',
+        1000,
+        {},
+        gateway.info,
+      ),
+    ).resolves.toBeDefined()
+  },
+)
+
+walletTest('payInvoice should pay a bolt11 invoice', async ({ wallet }) => {
   expect(wallet).toBeDefined()
   expect(wallet.isOpen()).toBe(true)
 
diff --git a/packages/core-web/src/test/TestingService.ts b/packages/core-web/src/test/TestingService.ts
index 42932d4..f43c0f7 100644
--- a/packages/core-web/src/test/TestingService.ts
+++ b/packages/core-web/src/test/TestingService.ts
@@ -1,13 +1,15 @@
 import { WorkerClient } from '../worker'
 
+export const TESTING_INVITE =
+  'fed11qgqrsdnhwden5te0v9cxjtt4dekxzamxw4kz6mmjvvkhydted9ukg6r9xfsnx7th0fhn26tf093juamwv4u8gtnpwpcz7qqpyz0e327ua8geceutfrcaezwt22mk6s2rdy09kg72jrcmncng2gn0kp2m5sk'
+
 // This is a testing service that allows for inspecting the internals
 // of the WorkerClient. It is not intended for use in production.
 export class TestingService {
   public TESTING_INVITE: string
   constructor(private client: WorkerClient) {
     // Solo Mint on mutinynet
-    this.TESTING_INVITE =
-      'fed11qgqrsdnhwden5te0v9cxjtt4dekxzamxw4kz6mmjvvkhydted9ukg6r9xfsnx7th0fhn26tf093juamwv4u8gtnpwpcz7qqpyz0e327ua8geceutfrcaezwt22mk6s2rdy09kg72jrcmncng2gn0kp2m5sk'
+    this.TESTING_INVITE = TESTING_INVITE
   }
 
   getRequestCounter() {
diff --git a/packages/core-web/src/test/setupTests.ts b/packages/core-web/src/test/setupTests.ts
new file mode 100644
index 0000000..6076ee0
--- /dev/null
+++ b/packages/core-web/src/test/setupTests.ts
@@ -0,0 +1,43 @@
+import { expect, test } from 'vitest'
+import { TestFedimintWallet } from './TestFedimintWallet'
+
+/**
+ * Adds Fixtures for setting up and tearing down a test FedimintWallet instance
+ */
+export const walletTest = test.extend<{ wallet: TestFedimintWallet }>({
+  wallet: async ({}, use) => {
+    const randomTestingId = Math.random().toString(36).substring(2, 15)
+    const wallet = new TestFedimintWallet()
+    expect(wallet).toBeDefined()
+
+    await expect(
+      wallet.joinFederation(wallet.testing.TESTING_INVITE, randomTestingId),
+    ).resolves.toBeUndefined()
+    await use(wallet)
+
+    // clear up browser resources
+    await wallet.cleanup()
+    // remove the wallet db
+    indexedDB.deleteDatabase(randomTestingId)
+  },
+})
+
+/**
+ * Adds Fixtures for setting up and tearing down a test Worker instance
+ */
+export const workerTest = test.extend<{
+  worker: Worker
+  clientName: string
+}>({
+  worker: async ({}, use) => {
+    const worker = new Worker(new URL('../worker/worker.js', import.meta.url), {
+      type: 'module',
+    })
+    await use(worker)
+    worker.terminate()
+  },
+  clientName: async ({}, use) => {
+    const randomTestingId = Math.random().toString(36).substring(2, 15)
+    await use(randomTestingId)
+  },
+})
diff --git a/packages/core-web/src/worker/worker.js b/packages/core-web/src/worker/worker.js
index 0375300..9adc421 100644
--- a/packages/core-web/src/worker/worker.js
+++ b/packages/core-web/src/worker/worker.js
@@ -1,9 +1,12 @@
 // Web Worker for fedimint-client-wasm to run in the browser
 
 // HACK: Fixes vitest browser runner
+// TODO: remove once https://github.com/vitest-dev/vitest/pull/6569 lands in a release
 globalThis.__vitest_browser_runner__ = { wrapDynamicImport: (foo) => foo() }
 
+// dynamically imported Constructor for WasmClient
 let WasmClient = null
+// client instance
 let client = null
 
 const streamCancelMap = new Map()
diff --git a/packages/core-web/src/worker/worker.test.ts b/packages/core-web/src/worker/worker.test.ts
new file mode 100644
index 0000000..6f43846
--- /dev/null
+++ b/packages/core-web/src/worker/worker.test.ts
@@ -0,0 +1,93 @@
+import { expect } from 'vitest'
+import { JSONObject } from '../types/wallet'
+import { TESTING_INVITE } from '../test/TestingService'
+import { workerTest } from '../test/setupTests'
+
+// Waits for a message of a given type from the worker
+const waitForWorkerResponse = (
+  worker: Worker,
+  messageType: string,
+): Promise<JSONObject> => {
+  return new Promise((resolve, reject) => {
+    worker.onmessage = (event) => {
+      if (event.data.type === messageType) {
+        resolve(event.data)
+      } else if (event.data.type === 'error') {
+        reject(event.data.error)
+      }
+    }
+    worker.onerror = (error) => {
+      reject(error.message)
+    }
+  })
+}
+
+workerTest(
+  'should initialize WasmClient on init message',
+  async ({ worker }) => {
+    worker.postMessage({ type: 'init', requestId: 1 })
+    const response = await waitForWorkerResponse(worker, 'initialized')
+    expect(response.data).toEqual({})
+  },
+)
+
+workerTest(
+  'should return false on open for a new client',
+  async ({ worker, clientName }) => {
+    worker.postMessage({ type: 'init', requestId: 1 })
+    await waitForWorkerResponse(worker, 'initialized')
+
+    worker.postMessage({
+      type: 'open',
+      requestId: 2,
+      payload: { clientName },
+    })
+    const response = await waitForWorkerResponse(worker, 'open')
+    expect(response.data).toEqual({ success: false })
+  },
+)
+
+workerTest(
+  'should error on fake federation invitation',
+  async ({ worker, clientName }) => {
+    worker.postMessage({ type: 'init', requestId: 1 })
+    await waitForWorkerResponse(worker, 'initialized')
+
+    worker.postMessage({
+      type: 'join',
+      requestId: 2,
+      payload: { inviteCode: 'fakefederationinvitation', clientName },
+    })
+    try {
+      await waitForWorkerResponse(worker, 'open')
+      expect.unreachable()
+    } catch (e) {
+      expect(e).toBe('parsing failed')
+    }
+  },
+)
+
+workerTest(
+  'should handle joining a federation',
+  async ({ worker, clientName }) => {
+    worker.postMessage({ type: 'init', requestId: 1 })
+    await waitForWorkerResponse(worker, 'initialized')
+
+    worker.postMessage({
+      type: 'join',
+      requestId: 2,
+      payload: { inviteCode: TESTING_INVITE, clientName },
+    })
+    const response = await waitForWorkerResponse(worker, 'join')
+    expect(response.data).toEqual({ success: true })
+  },
+)
+
+workerTest(
+  'should handle unknown message type',
+  async ({ worker, clientName }) => {
+    worker.postMessage({ type: 'unknown', requestId: 2 })
+    const response = await waitForWorkerResponse(worker, 'error')
+    expect(response.error).toBe('Unknown message type')
+  },
+)
diff --git a/vitest.workspace.ts b/vitest.workspace.ts
index a7b8092..2b6664b 100644
--- a/vitest.workspace.ts
+++ b/vitest.workspace.ts
@@ -17,6 +17,7 @@ export default defineWorkspace([
         api: {
           port: 63315,
         },
+        screenshotFailures: false,
       },
     },
   },
