test: avoid real-time waits in NIP-40 integration

Author: Priyanshubhartistm

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

@@ -16,10 +16,9 @@ Feature: NIP-40 Event expiration for standalone events
     And Bob subscribes to text_note events from Alice
     Then Bob receives a text_note event from Alice with content "not yet expired"
 
-  Scenario: Stored event is not returned to new subscribers after expiration time passes
+  Scenario: Stored expired event is not returned to new subscribers
     Given someone called Alice
     And someone called Bob
-    When Alice sends a text_note event with content "short lived" and expiration in 2 seconds
-    And Bob waits until Alice's last text_note event expires
+    When Alice has a stored text_note event with content "short lived" and expiration in the past
     And Bob subscribes to text_note events from Alice
     Then Bob receives 0 text_note events and EOSE

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

@@ -3,19 +3,13 @@ import { expect } from 'chai'
 import WebSocket from 'ws'
 
 import { createEvent, createSubscription, publishEvent, waitForEventCount } from '../helpers'
-import { Event, ExpiringEvent } from '../../../../src/@types/event'
+import { ExpiringEvent } from '../../../../src/@types/event'
 import { EventExpirationTimeMetadataKey, EventKinds, EventTags } from '../../../../src/constants/base'
+import { getMasterDbClient } from '../../../../src/database/client'
+import { EventRepository } from '../../../../src/repositories/event-repository'
 
 const now = (): number => Math.floor(Date.now() / 1000)
 
-const wait = async (ms: number): Promise<void> => {
-  if (ms <= 0) {
-    return
-  }
-
-  await new Promise<void>((resolve) => setTimeout(resolve, ms))
-}
-
 const createTextNoteWithExpiration = async (
   world: World<Record<string, any>>,
   name: string,
@@ -44,6 +38,37 @@ const createTextNoteWithExpiration = async (
   return event
 }
 
+const seedStoredTextNoteWithExpiration = async (
+  world: World<Record<string, any>>,
+  name: string,
+  content: string,
+  expirationTime: number,
+): Promise<ExpiringEvent> => {
+  const { pubkey, privkey } = world.parameters.identities[name]
+  const dbClient = getMasterDbClient()
+  const repository = new EventRepository(dbClient, dbClient)
+
+  const event = await createEvent(
+    {
+      pubkey,
+      kind: EventKinds.TEXT_NOTE,
+      created_at: expirationTime - 30,
+      content,
+      tags: [[EventTags.Expiration, expirationTime.toString()]],
+    },
+    privkey,
+  ) as ExpiringEvent
+
+  event[EventExpirationTimeMetadataKey] = expirationTime
+
+  const inserted = await repository.create(event)
+  expect(inserted).to.equal(1)
+
+  world.parameters.events[name].push(event)
+
+  return event
+}
+
 When(/^(\w+) sends a text_note event with content "([^"]+)" and expiration in the past$/, async function(
   this: World<Record<string, any>>,
   name: string,
@@ -60,6 +85,14 @@ When(/^(\w+) sends a text_note event with content "([^"]+)" and expiration in th
   await createTextNoteWithExpiration(this, name, content, now() + 30)
 })
 
+When(/^(\w+) has a stored text_note event with content "([^"]+)" and expiration in the past$/, async function(
+  this: World<Record<string, any>>,
+  name: string,
+  content: string,
+) {
+  await seedStoredTextNoteWithExpiration(this, name, content, now() - 10)
+})
+
 When(/^(\w+) sends a text_note event with content "([^"]+)" and expiration in (\d+) seconds$/, async function(
   this: World<Record<string, any>>,
   name: string,
@@ -74,22 +107,6 @@ When(/^(\w+) sends a text_note event with content "([^"]+)" and expiration in (\
   expect(Number(expirationTag?.[1])).to.equal(expirationTime)
 })
 
-When(/^(\w+) waits until (\w+)'s last text_note event expires$/, async function(
-  this: World<Record<string, any>>,
-  _name: string,
-  author: string,
-) {
-  const events = this.parameters.events[author] as Event[]
-  const event = events[events.length - 1] as ExpiringEvent
-  const expirationTime = event[EventExpirationTimeMetadataKey]
-
-  expect(expirationTime).to.be.a('number')
-
-  const millisecondsUntilExpired = (Number(expirationTime) - now() + 1) * 1000
-
-  await wait(millisecondsUntilExpired)
-})
-
 When(/^(\w+) subscribes to text_note events from (\w+)$/, async function(
   this: World<Record<string, any>>,
   name: string,