test(integration): add NIP-62 vanish tests and fix test enviroment

Author: vikashsiwach

.changeset/nip-62-integration-tests.md

@@ -0,0 +1,5 @@
+---
+"nostream": patch
+---
+
+Add NIP-62 integration tests for Request to Vanish

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

@@ -0,0 +1,15 @@
+Feature: NIP-62
+  Scenario: Alice requests to vanish
+    Given someone called Alice
+    And someone called Bob
+    And Alice sends a set_metadata event
+    And Alice sends a text_note event with content "please forget this"
+    When Alice sends a request_to_vanish event
+    And Bob subscribes to author Alice
+    Then Bob receives 1 request_to_vanish event from Alice and EOSE
+
+  Scenario: Alice cannot publish after requesting to vanish
+    Given someone called Alice
+    When Alice sends a request_to_vanish event
+    And Alice drafts a text_note event with content "I should be blocked"
+    Then Alice sends their last draft event unsuccessfully because "blocked: request to vanish active for pubkey"

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

@@ -0,0 +1,49 @@
+import { Then, When } from '@cucumber/cucumber'
+import { expect } from 'chai'
+import WebSocket from 'ws'
+
+import { createEvent, sendEvent, waitForEventCount } from '../helpers'
+import { ALL_RELAYS, EventKinds, EventTags } from '../../../../src/constants/base'
+import { Event } from '../../../../src/@types/event'
+import { isDraft } from '../shared'
+
+When(/^(\w+) sends a request_to_vanish event$/, async function (name: string) {
+  const ws = this.parameters.clients[name] as WebSocket
+  const { pubkey, privkey } = this.parameters.identities[name]
+
+  const event: Event = await createEvent(
+    { pubkey, kind: EventKinds.REQUEST_TO_VANISH, content: '', tags: [[EventTags.Relay, ALL_RELAYS]] },
+    privkey,
+  )
+
+  await sendEvent(ws, event)
+  this.parameters.events[name].push(event)
+})
+
+Then(
+  /(\w+) receives (\d+) request_to_vanish events? from (\w+) and EOSE$/,
+  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)
+  },
+)
+
+Then(
+  /^(\w+) sends their last draft event unsuccessfully because "([^"]+)"$/,
+  async function (name: string, reason: string) {
+    const ws = this.parameters.clients[name] as WebSocket
+    const event = this.parameters.events[name].findLast((event: Event) => event[isDraft])
+
+    delete event[isDraft]
+
+    const command = await sendEvent(ws, event, false)
+    expect(command[1]).to.equal(event.id)
+    expect(command[2]).to.be.false
+    expect(command[3]).to.equal(reason)
+  },
+)

test/integration/features/shared.ts

@@ -1,4 +1,4 @@
-import { After, AfterAll, Before, BeforeAll, Given, Then, When, World } from '@cucumber/cucumber'
+import { After, AfterAll, Before, BeforeAll, Given, Then, When, World, setDefaultTimeout } from '@cucumber/cucumber'
 import { assocPath, pipe } from 'ramda'
 import { fromEvent, map, Observable, ReplaySubject, Subject, takeUntil } from 'rxjs'
 import WebSocket, { MessageEvent } from 'ws'
@@ -15,19 +15,32 @@ 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>>()
 
-BeforeAll({ timeout: 1000 }, async function () {
+setDefaultTimeout(30000)
+
+BeforeAll(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()
 
@@ -45,9 +58,16 @@ BeforeAll({ timeout: 1000 }, 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([dbClient.destroy(), rrDbClient.destroy()])
+      await Promise.all(clients.map((client) => client.destroy()))
       resolve()
     })
   })
@@ -63,11 +83,13 @@ 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')
@@ -78,20 +100,22 @@ 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')
@@ -104,7 +128,12 @@ 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)
@@ -113,6 +142,7 @@ 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()))
   })