fix Queue, tweaks on relay.ts and make relay.test.ts pass.

relay.test.ts

@@ -1,125 +1,99 @@
-import { test, expect } from 'bun:test'
-import 'websocket-polyfill'
+import { test, expect, afterEach, beforeEach } from 'bun:test'
 
 import { finishEvent } from './event.ts'
 import { generatePrivateKey, getPublicKey } from './keys.ts'
-import { relayInit } from './relay.ts'
+import { Relay } from './relay.ts'
 
-let relay = relayInit('wss://relay.damus.io/')
+let relay = new Relay('wss://public.relaying.io')
 
-beforeAll(() => {
+beforeEach(() => {
   relay.connect()
 })
 
-afterAll(() => {
+afterEach(() => {
   relay.close()
 })
 
-test('connectivity', () => {
-  return expect(
-    new Promise(resolve => {
-      relay.on('connect', () => {
-        resolve(true)
-      })
-      relay.on('error', () => {
-        resolve(false)
-      })
-    }),
-  ).resolves.toBe(true)
+test('connectivity', async () => {
+  await relay.connect()
+  expect(relay.connected).toBeTrue()
 })
 
 test('querying', async () => {
-  var resolve1: (value: boolean) => void
-  var resolve2: (value: boolean) => void
+  let resolve1: () => void
+  let resolve2: () => void
 
-  let sub = relay.sub([
-    {
-      ids: ['d7dd5eb3ab747e16f8d0212d53032ea2a7cadef53837e5a6c66d42849fcb9027'],
-    },
-  ])
-  sub.on('event', event => {
-    expect(event).toHaveProperty('id', 'd7dd5eb3ab747e16f8d0212d53032ea2a7cadef53837e5a6c66d42849fcb9027')
-    resolve1(true)
-  })
-  sub.on('eose', () => {
-    resolve2(true)
-  })
-
-  let [t1, t2] = await Promise.all([
-    new Promise<boolean>(resolve => {
+  let waiting = Promise.all([
+    new Promise<void>(resolve => {
       resolve1 = resolve
     }),
-    new Promise<boolean>(resolve => {
+    new Promise<void>(resolve => {
       resolve2 = resolve
     }),
   ])
 
-  expect(t1).toEqual(true)
-  expect(t2).toEqual(true)
+  relay.subscribe(
+    [
+      {
+        ids: ['3abc6cbb215af0412ab2c9c8895d96a084297890fd0b4018f8427453350ca2e4'],
+      },
+    ],
+    {
+      onevent(event) {
+        expect(event).toHaveProperty('id', '3abc6cbb215af0412ab2c9c8895d96a084297890fd0b4018f8427453350ca2e4')
+        expect(event).toHaveProperty('content', '+')
+        expect(event).toHaveProperty('kind', 7)
+        resolve1()
+      },
+      oneose() {
+        resolve2()
+      },
+    },
+  )
+
+  let [t1, t2] = await waiting
+  expect(t1).toBeUndefined()
+  expect(t2).toBeUndefined()
 }, 10000)
 
-test('async iterator', async () => {
-  let sub = relay.sub([
-    {
-      ids: ['d7dd5eb3ab747e16f8d0212d53032ea2a7cadef53837e5a6c66d42849fcb9027'],
-    },
-  ])
-
-  for await (const event of sub.events) {
-    expect(event).toHaveProperty('id', 'd7dd5eb3ab747e16f8d0212d53032ea2a7cadef53837e5a6c66d42849fcb9027')
-    break
-  }
-})
-
-test('get()', async () => {
-  let event = await relay.get({
-    ids: ['d7dd5eb3ab747e16f8d0212d53032ea2a7cadef53837e5a6c66d42849fcb9027'],
-  })
-
-  expect(event).toHaveProperty('id', 'd7dd5eb3ab747e16f8d0212d53032ea2a7cadef53837e5a6c66d42849fcb9027')
-})
-
-test('list()', async () => {
-  let events = await relay.list([
-    {
-      authors: ['3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d'],
-      kinds: [1],
-      limit: 2,
-    },
-  ])
-
-  expect(events.length).toEqual(2)
-})
-
-test('listening (twice) and publishing', async () => {
+test('listening and publishing and closing', async () => {
   let sk = generatePrivateKey()
   let pk = getPublicKey(sk)
-  var resolve1: (value: boolean) => void
-  var resolve2: (value: boolean) => void
+  var resolve1: (_: void) => void
+  var resolve2: (_: void) => void
 
-  let sub = relay.sub([
-    {
-      kinds: [27572],
-      authors: [pk],
-    },
+  let waiting = Promise.all([
+    new Promise(resolve => {
+      resolve1 = resolve
+    }),
+    new Promise(resolve => {
+      resolve2 = resolve
+    }),
   ])
 
-  sub.on('event', event => {
-    expect(event).toHaveProperty('pubkey', pk)
-    expect(event).toHaveProperty('kind', 27572)
-    expect(event).toHaveProperty('content', 'nostr-tools test suite')
-    resolve1(true)
-  })
-  sub.on('event', event => {
-    expect(event).toHaveProperty('pubkey', pk)
-    expect(event).toHaveProperty('kind', 27572)
-    expect(event).toHaveProperty('content', 'nostr-tools test suite')
-    resolve2(true)
-  })
+  let sub = await relay.subscribe(
+    [
+      {
+        kinds: [23571],
+        authors: [pk],
+      },
+    ],
+    {
+      onevent(event) {
+        expect(event).toHaveProperty('pubkey', pk)
+        expect(event).toHaveProperty('kind', 23571)
+        expect(event).toHaveProperty('content', 'nostr-tools test suite')
+        resolve1()
+      },
+      onclose() {
+        resolve2()
+      },
+    },
+  )
 
   let event = finishEvent(
     {
-      kind: 27572,
+      kind: 23571,
       created_at: Math.floor(Date.now() / 1000),
       tags: [],
       content: 'nostr-tools test suite',
@@ -127,15 +101,10 @@ test('listening (twice) and publishing', async () => {
     sk,
   )
 
-  relay.publish(event)
-  return expect(
-    Promise.all([
-      new Promise(resolve => {
-        resolve1 = resolve
-      }),
-      new Promise(resolve => {
-        resolve2 = resolve
-      }),
-    ]),
-  ).resolves.toEqual([true, true])
+  await relay.publish(event)
+  sub.close()
+
+  let [t1, t2] = await waiting
+  expect(t1).toBeUndefined()
+  expect(t2).toBeUndefined()
 })