refactor pool.test.ts and update with new mock relay class

pool.test.ts

@@ -1,35 +1,32 @@
-import { test, expect, afterAll } from 'bun:test'
+import { afterEach, beforeEach, expect, test } from 'bun:test'
 
-import { finalizeEvent, type Event } from './pure.ts'
-import { generateSecretKey, getPublicKey } from './pure.ts'
 import { SimplePool } from './pool.ts'
-import { newMockRelay } from './test-helpers.ts'
+import { finalizeEvent, generateSecretKey, getPublicKey, type Event } from './pure.ts'
+import { MockRelay } from './test-helpers.ts'
 
-let pool = new SimplePool()
+let pool: SimplePool
+let mockRelays: MockRelay[]
+let relayURLs: string[]
 
-let mockRelays = [newMockRelay(), newMockRelay(), newMockRelay(), newMockRelay()]
+beforeEach(() => {
-let relays = mockRelays.map(mr => mr.url)
+  pool = new SimplePool()
-let authors = mockRelays.flatMap(mr => mr.authors)
+  mockRelays = Array.from({ length: 10 }, () => new MockRelay())
-let ids = mockRelays.flatMap(mr => mr.ids)
+  relayURLs = mockRelays.map(mr => mr.getUrl())
+})
 
-afterAll(() => {
+afterEach(() => {
-  pool.close(relays)
+  pool.close(relayURLs)
+
+  for (let mr of mockRelays) {
+    mr.close()
+    mr.stop()
+  }
 })
 
 test('removing duplicates when subscribing', async () => {
   let priv = generateSecretKey()
   let pub = getPublicKey(priv)
-
-  pool.subscribeMany(relays, [{ authors: [pub] }], {
-    onevent(event: Event) {
-      // this should be called only once even though we're listening
-      // to multiple relays because the events will be caught and
-      // deduplicated efficiently (without even being parsed)
-      received.push(event)
-    },
-  })
   let received: Event[] = []
-
   let event = finalizeEvent(
     {
       created_at: Math.round(Date.now() / 1000),
@@ -40,8 +37,17 @@ test('removing duplicates when subscribing', async () => {
     priv,
   )
 
-  await Promise.any(pool.publish(relays, event))
+  pool.subscribeMany(relayURLs, [{ authors: [pub] }], {
-  await new Promise(resolve => setTimeout(resolve, 1500))
+    onevent(event: Event) {
+      // this should be called only once even though we're listening
+      // to multiple relays because the events will be caught and
+      // deduplicated efficiently (without even being parsed)
+      received.push(event)
+    },
+  })
+
+  await Promise.any(pool.publish(relayURLs, event))
+  await new Promise(resolve => setTimeout(resolve, 200)) // wait for the new published event to be received
 
   expect(received).toHaveLength(1)
   expect(received[0]).toEqual(event)
@@ -51,12 +57,12 @@ test('same with double subs', async () => {
   let priv = generateSecretKey()
   let pub = getPublicKey(priv)
 
-  pool.subscribeMany(relays, [{ authors: [pub] }], {
+  pool.subscribeMany(relayURLs, [{ authors: [pub] }], {
     onevent(event) {
       received.push(event)
     },
   })
-  pool.subscribeMany(relays, [{ authors: [pub] }], {
+  pool.subscribeMany(relayURLs, [{ authors: [pub] }], {
     onevent(event) {
       received.push(event)
     },
@@ -74,47 +80,47 @@ test('same with double subs', async () => {
     priv,
   )
 
-  await Promise.any(pool.publish(relays, event))
+  await Promise.any(pool.publish(relayURLs, event))
-  await new Promise(resolve => setTimeout(resolve, 1500))
+  await new Promise(resolve => setTimeout(resolve, 200)) // wait for the new published event to be received
 
   expect(received).toHaveLength(2)
 })
 
 test('query a bunch of events and cancel on eose', async () => {
   let events = new Set<string>()
+
   await new Promise<void>(resolve => {
-    pool.subscribeManyEose(
+    pool.subscribeManyEose(relayURLs, [{ kinds: [0, 1, 2, 3, 4, 5, 6], limit: 40 }], {
-      [...relays, ...relays, 'wss://relayable.org', 'wss://relay.noswhere.com', 'wss://nothing.com'],
+      onevent(event) {
-      [{ kinds: [0, 1, 2, 3, 4, 5, 6], limit: 40 }],
+        events.add(event.id)
-      {
-        onevent(event) {
-          events.add(event.id)
-        },
-        onclose: resolve as any,
       },
-    )
+      onclose: resolve as any,
+    })
   })
+
   expect(events.size).toBeGreaterThan(50)
 })
 
 test('querySync()', async () => {
-  let events = await pool.querySync(
+  let authors = mockRelays.flatMap(mr => mr.getAuthors())
-    [...relays.slice(0, 2), ...relays.slice(0, 2), 'wss://offchain.pub', 'wss://eden.nostr.land'],
+
-    {
+  let events = await pool.querySync(relayURLs, {
-      authors: authors.slice(0, 2),
+    authors: authors,
-      kinds: [1],
+    kinds: [1],
-      limit: 2,
+    limit: 2,
-    },
+  })
-  )
+
+  const uniqueEventCount = new Set(events.map(evt => evt.id)).size
 
   // the actual received number will be greater than 2, but there will be no duplicates
   expect(events.length).toBeGreaterThan(2)
-  const uniqueEventCount = new Set(events.map(evt => evt.id)).size
   expect(events).toHaveLength(uniqueEventCount)
 })
 
 test('get()', async () => {
-  let event = await pool.get(relays, {
+  let ids = mockRelays.flatMap(mr => mr.getEventsIds())
+
+  let event = await pool.get(relayURLs, {
     ids: [ids[0]],
   })