test(integration): improve NIP-62 assertions

Author: vikashsiwach

test/integration/features/nip-62/nip-62.feature.ts

@@ -25,11 +25,15 @@ Then(
   async function (name: string, count: string, author: string) {
     const ws = this.parameters.clients[name] as WebSocket
     const subscription = this.parameters.subscriptions[name][this.parameters.subscriptions[name].length - 1]
-    const events = await waitForEventCount(ws, subscription.name, Number(count), true)
-
-    expect(events.length).to.equal(Number(count))
-    expect(events[0].kind).to.equal(EventKinds.REQUEST_TO_VANISH)
-    expect(events[0].pubkey).to.equal(this.parameters.identities[author].pubkey)
+    const expectedCount = Number(count)
+    const expectedPubkey = this.parameters.identities[author].pubkey
+    const events = await waitForEventCount(ws, subscription.name, expectedCount, true)
+
+    expect(events.length).to.equal(expectedCount)
+    for (const event of events) {
+      expect(event.kind).to.equal(EventKinds.REQUEST_TO_VANISH)
+      expect(event.pubkey).to.equal(expectedPubkey)
+    }
   },
 )
 
@@ -39,6 +43,10 @@ Then(
     const ws = this.parameters.clients[name] as WebSocket
     const event = this.parameters.events[name].findLast((event: Event) => event[isDraft])
 
+    if (!event) {
+      throw new Error(`No draft event found for ${name}`)
+    }
+
     delete event[isDraft]
 
     const command = await sendEvent(ws, event, false)

test/integration/features/shared.ts

@@ -1,4 +1,4 @@
-import { After, AfterAll, Before, BeforeAll, Given, Then, When, World, setDefaultTimeout } from '@cucumber/cucumber'
+import { After, AfterAll, Before, BeforeAll, Given, Then, When, World } from '@cucumber/cucumber'
 import { assocPath, pipe } from 'ramda'
 import { fromEvent, map, Observable, ReplaySubject, Subject, takeUntil } from 'rxjs'
 import WebSocket, { MessageEvent } from 'ws'
@@ -15,32 +15,19 @@ import { workerFactory } from '../../../src/factories/worker-factory'
 export const isDraft = Symbol('draft')
 
 let worker: AppWorker
+
 let dbClient: DatabaseClient
 let rrDbClient: DatabaseClient
 
 export const streams = new WeakMap<WebSocket, Observable<unknown>>()
 
-setDefaultTimeout(30000)
-
-BeforeAll(async function () {
+BeforeAll({ timeout: 1000 }, async function () {
   process.env.RELAY_PORT = '18808'
   process.env.SECRET = Math.random().toString().repeat(6)
-
-  process.env.DB_HOST ??= 'localhost'
-  process.env.DB_PORT ??= '5432'
-  process.env.DB_USER ??= 'postgres'
-  process.env.DB_PASSWORD ??= 'postgres'
-  process.env.DB_NAME ??= 'nostr_ts_relay_test'
-  process.env.DB_MIN_POOL_SIZE ??= '1'
-  process.env.DB_MAX_POOL_SIZE ??= '2'
-  process.env.DB_ACQUIRE_CONNECTION_TIMEOUT ??= '10000'
-
   dbClient = getMasterDbClient()
   rrDbClient = getReadReplicaDbClient()
-
   await dbClient.raw('SELECT 1=1')
   await rrDbClient.raw('SELECT 1=1')
-
   Sinon.stub(SettingsStatic, 'watchSettings')
   const settings = SettingsStatic.createSettings()
 
@@ -58,16 +45,9 @@ BeforeAll(async function () {
 })
 
 AfterAll({ timeout: 30000 }, async function () {
-  const clients = [...new Set([dbClient, rrDbClient].filter(Boolean))]
-
   await new Promise<void>((resolve) => {
-    if (!worker) {
-      void Promise.all(clients.map((client) => client.destroy())).then(() => resolve())
-      return
-    }
-
     worker.close(async () => {
-      await Promise.all(clients.map((client) => client.destroy()))
+      await Promise.all([dbClient.destroy(), rrDbClient.destroy()])
       resolve()
     })
   })
@@ -83,13 +63,11 @@ Before(function () {
 After(async function () {
   this.parameters.events = {}
   this.parameters.subscriptions = {}
-
   for (const ws of Object.values(this.parameters.clients as Record<string, WebSocket>)) {
     if (ws && ws.readyState === WebSocket.OPEN) {
       ws.close()
     }
   }
-
   this.parameters.clients = {}
 
   await dbClient('events')
@@ -100,22 +78,20 @@ After(async function () {
       ),
     )
     .delete()
-
   this.parameters.identities = {}
 })
 
 Given(/someone called (\w+)/, async function (name: string) {
   const connection = await connect(name)
-
   this.parameters.identities[name] = this.parameters.identities[name] ?? createIdentity(name)
   this.parameters.clients[name] = connection
   this.parameters.subscriptions[name] = []
   this.parameters.events[name] = []
-
   const close = new Subject()
   connection.once('close', close.next.bind(close))
 
   const projection = (raw: MessageEvent) => JSON.parse(raw.data.toString('utf8'))
+
   const replaySubject = new ReplaySubject(2, 1000)
 
   fromEvent(connection, 'message')
@@ -128,12 +104,7 @@ Given(/someone called (\w+)/, async function (name: string) {
 When(/(\w+) subscribes to author (\w+)$/, async function (this: World<Record<string, any>>, from: string, to: string) {
   const ws = this.parameters.clients[from] as WebSocket
   const pubkey = this.parameters.identities[to].pubkey
-
-  const subscription = {
-    name: `test-${Math.random()}`,
-    filters: [{ authors: [pubkey] }],
-  }
-
+  const subscription = { name: `test-${Math.random()}`, filters: [{ authors: [pubkey] }] }
   this.parameters.subscriptions[from].push(subscription)
 
   await createSubscription(ws, subscription.name, subscription.filters)
@@ -142,7 +113,6 @@ When(/(\w+) subscribes to author (\w+)$/, async function (this: World<Record<str
 Then(/(\w+) unsubscribes from author \w+/, async function (from: string) {
   const ws = this.parameters.clients[from] as WebSocket
   const subscription = this.parameters.subscriptions[from].pop()
-
   return new Promise<void>((resolve, reject) => {
     ws.send(JSON.stringify(['CLOSE', subscription.name]), (err) => (err ? reject(err) : resolve()))
   })