Merge pull request #358 from sepehr-safari/mock-relay-class

Enhance Mock Relay

nip11.test.ts

@@ -2,6 +2,7 @@ import { describe, test, expect } from 'bun:test'
 import fetch from 'node-fetch'
 import { useFetchImplementation, fetchRelayInformation } from './nip11'
 
+// TODO: replace with a mock
 describe('requesting relay as for NIP11', () => {
   useFetchImplementation(fetch)
 

nip42.test.ts

@@ -1,14 +1,16 @@
-import { test, expect } from 'bun:test'
+import { expect, test } from 'bun:test'
 
 import { makeAuthEvent } from './nip42.ts'
 import { Relay } from './relay.ts'
+import { MockRelay } from './test-helpers.ts'
 
 test('auth flow', async () => {
-  const relay = await Relay.connect('wss://nostr.wine')
+  const mockRelay = new MockRelay()
-
+  const relay = await Relay.connect(mockRelay.getUrl())
   const auth = makeAuthEvent(relay.url, 'chachacha')
+
   expect(auth.tags).toHaveLength(2)
-  expect(auth.tags[0]).toEqual(['relay', 'wss://nostr.wine/'])
+  expect(auth.tags[0]).toEqual(['relay', mockRelay.getUrl()])
   expect(auth.tags[1]).toEqual(['challenge', 'chachacha'])
   expect(auth.kind).toEqual(22242)
 })

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]],
   })
 

relay.test.ts

@@ -2,43 +2,57 @@ import { expect, test } from 'bun:test'
 
 import { finalizeEvent, generateSecretKey, getPublicKey } from './pure.ts'
 import { Relay } from './relay.ts'
-import { newMockRelay } from './test-helpers.ts'
+import { MockRelay } from './test-helpers.ts'
 
 test('connectivity', async () => {
-  const { url } = newMockRelay()
+  const mockRelay = new MockRelay()
-  const relay = new Relay(url)
+
+  const relay = new Relay(mockRelay.getUrl())
   await relay.connect()
+
   expect(relay.connected).toBeTrue()
+
   relay.close()
+  mockRelay.close()
+  mockRelay.stop()
 })
 
 test('connectivity, with Relay.connect()', async () => {
-  const { url } = newMockRelay()
+  const mockRelay = new MockRelay()
-  const relay = await Relay.connect(url)
+
+  const relay = await Relay.connect(mockRelay.getUrl())
+
   expect(relay.connected).toBeTrue()
+
   relay.close()
+  mockRelay.close()
+  mockRelay.stop()
 })
 
 test('querying', async done => {
-  const { url, authors } = newMockRelay()
+  const mockRelay = new MockRelay()
+
   const kind = 0
 
-  const relay = new Relay(url)
+  const relay = new Relay(mockRelay.getUrl())
   await relay.connect()
 
   relay.subscribe(
     [
       {
-        authors: authors,
+        authors: mockRelay.getAuthors(),
         kinds: [kind],
       },
     ],
     {
       onevent(event) {
-        expect(authors).toContain(event.pubkey)
+        expect(mockRelay.getAuthors()).toContain(event.pubkey)
         expect(event).toHaveProperty('kind', kind)
 
         relay.close()
+        mockRelay.close()
+        mockRelay.stop()
+
         done()
       },
     },
@@ -46,12 +60,13 @@ test('querying', async done => {
 })
 
 test('listening and publishing and closing', async done => {
+  const mockRelay = new MockRelay()
+
   const sk = generateSecretKey()
   const pk = getPublicKey(sk)
   const kind = 23571
 
-  const { url } = newMockRelay()
+  const relay = new Relay(mockRelay.getUrl())
-  const relay = new Relay(url)
   await relay.connect()
 
   let sub = relay.subscribe(
@@ -66,11 +81,15 @@ test('listening and publishing and closing', async done => {
         expect(event).toHaveProperty('pubkey', pk)
         expect(event).toHaveProperty('kind', kind)
         expect(event).toHaveProperty('content', 'content')
-        sub.close()
+
+        sub.close() // close the subscription and will trigger onclose()
       },
-      oneose() {},
       onclose() {
         relay.close()
+
+        mockRelay.close()
+        mockRelay.stop()
+
         done()
       },
     },

test-helpers.ts

@@ -16,80 +16,142 @@ export function buildEvent(params: Partial<Event>): Event {
   }
 }
 
-let serial = 0
+/**
+ * A mock Relay class for testing purposes.
+ * This mock relay returns some events before eose and then will be ok with everything.
+ * @class
+ * @example
+ * const mockRelay = new MockRelay()
+ * const relay = new Relay(mockRelay.getUrl())
+ * await relay.connect()
+ * // Do some testing
+ * relay.close()
+ * mockRelay.close()
+ * mockRelay.stop()
+ */
+export class MockRelay {
+  private _url: string
+  private _server: Server
+  private _secretKeys: Uint8Array[]
+  private _preloadedEvents: Event[]
 
-// the mock relay will always return some events before eose and then be ok with everything
+  constructor(url?: string | undefined) {
-export function newMockRelay(): { url: string; authors: string[]; ids: string[] } {
+    this._url = url ?? `wss://random.mock.relay/${Math.floor(Math.random() * 10000)}`
-  serial++
+    this._server = new Server(this._url)
-  const url = `wss://mock.relay.url/${serial}`
+    this._secretKeys = [generateSecretKey(), generateSecretKey(), generateSecretKey(), generateSecretKey()]
-  const relay = new Server(url)
+    this._preloadedEvents = this._secretKeys.map(sk =>
-  const secretKeys = [generateSecretKey(), generateSecretKey(), generateSecretKey(), generateSecretKey()]
+      finalizeEvent(
-  const preloadedEvents = secretKeys.map(sk =>
+        {
-    finalizeEvent(
+          kind: 1,
-      {
+          content: '',
-        kind: 1,
+          created_at: Math.floor(Date.now() / 1000),
-        content: '',
+          tags: [],
-        created_at: Math.floor(Date.now() / 1000),
+        },
-        tags: [],
+        sk,
-      },
+      ),
-      sk,
+    )
-    ),
-  )
 
-  relay.on('connection', (conn: any) => {
+    this._server.on('connection', (conn: any) => {
-    let subs: { [subId: string]: { conn: any; filters: Filter[] } } = {}
+      let subs: { [subId: string]: { conn: any; filters: Filter[] } } = {}
 
-    conn.on('message', (message: string) => {
+      conn.on('message', (message: string) => {
-      const data = JSON.parse(message)
+        const data = JSON.parse(message)
-      switch (data[0]) {
-        case 'REQ': {
-          let subId = data[1]
-          let filters = data.slice(2)
-          subs[subId] = { conn, filters }
 
-          preloadedEvents.forEach(event => {
+        switch (data[0]) {
-            conn.send(JSON.stringify(['EVENT', subId, event]))
+          case 'REQ': {
-          })
+            let subId = data[1]
+            let filters = data.slice(2)
+            subs[subId] = { conn, filters }
 
-          filters.forEach((filter: Filter) => {
+            this._preloadedEvents.forEach(event => {
-            const kinds = filter.kinds?.length ? filter.kinds : [1]
+              conn.send(JSON.stringify(['EVENT', subId, event]))
-            kinds.forEach(kind => {
+            })
-              secretKeys.forEach(sk => {
+
-                const event = finalizeEvent(
+            filters.forEach((filter: Filter) => {
-                  {
+              const kinds = filter.kinds?.length ? filter.kinds : [1]
-                    kind,
+
-                    content: '',
+              kinds.forEach(kind => {
-                    created_at: Math.floor(Date.now() / 1000),
+                this._secretKeys.forEach(sk => {
-                    tags: [],
+                  const event = finalizeEvent(
-                  },
+                    {
-                  sk,
+                      kind,
-                )
+                      content: '',
-                conn.send(JSON.stringify(['EVENT', subId, event]))
+                      created_at: Math.floor(Date.now() / 1000),
+                      tags: [],
+                    },
+                    sk,
+                  )
+
+                  conn.send(JSON.stringify(['EVENT', subId, event]))
+                })
               })
             })
-          })
-          conn.send(JSON.stringify(['EOSE', subId]))
-          break
-        }
-        case 'CLOSE': {
-          let subId = data[1]
-          delete subs[subId]
-          break
-        }
-        case 'EVENT': {
-          let event = data[1]
-          conn.send(JSON.stringify(['OK', event.id, 'true']))
-          for (let subId in subs) {
-            const { filters, conn: listener } = subs[subId]
-            if (matchFilters(filters, event)) {
-              listener.send(JSON.stringify(['EVENT', subId, event]))
-            }
-          }
-          break
-        }
-      }
-    })
-  })
 
-  return { url, authors: secretKeys.map(getPublicKey), ids: preloadedEvents.map(evt => evt.id) }
+            conn.send(JSON.stringify(['EOSE', subId]))
+
+            break
+          }
+          case 'CLOSE': {
+            let subId = data[1]
+            delete subs[subId]
+
+            break
+          }
+          case 'EVENT': {
+            let event = data[1]
+
+            conn.send(JSON.stringify(['OK', event.id, 'true']))
+
+            for (let subId in subs) {
+              const { filters, conn: listener } = subs[subId]
+
+              if (matchFilters(filters, event)) {
+                listener.send(JSON.stringify(['EVENT', subId, event]))
+              }
+            }
+
+            break
+          }
+        }
+      })
+    })
+  }
+
+  /**
+   * Get the URL of the mock relay.
+   * @returns The URL of the mock relay.
+   */
+  getUrl() {
+    return this._url
+  }
+
+  /**
+   * Get the public keys of the authors of the events.
+   * @returns An array of public keys.
+   */
+  getAuthors() {
+    return this._secretKeys.map(getPublicKey)
+  }
+
+  /**
+   * Get the IDs of the events.
+   * @returns An array of event IDs.
+   */
+  getEventsIds() {
+    return this._preloadedEvents.map(evt => evt.id)
+  }
+
+  /**
+   * Close the mock relay server.
+   */
+  close() {
+    this._server.close()
+  }
+
+  /**
+   * Stop the mock relay server.
+   */
+  stop() {
+    this._server.stop()
+  }
 }