laantungir
/
nostr-tools
mirror of https://github.com/nbd-wtf/nostr-tools.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

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

Enhance Mock Relay
This commit is contained in:
fiatjaf_ 2024-01-20 08:36:40 -03:00 committed by GitHub
parent 6a9940c850 c453bc5ec3
commit 12147d4fee
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
5 changed files with 221 additions and 131 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
nip11.test.ts
View File

@ -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)

10
nip42.test.ts
View File

@ -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)
})

98
pool.test.ts
View File

@ -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()]
let relays = mockRelays.map(mr => mr.url)
let authors = mockRelays.flatMap(mr => mr.authors)
let ids = mockRelays.flatMap(mr => mr.ids)
beforeEach(() => {
pool = new SimplePool()
mockRelays = Array.from({ length: 10 }, () => new MockRelay())
relayURLs = mockRelays.map(mr => mr.getUrl())
})
afterAll(() => {
pool.close(relays)
afterEach(() => {
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))
await new Promise(resolve => setTimeout(resolve, 1500))
pool.subscribeMany(relayURLs, [{ 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)
},
})
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 new Promise(resolve => setTimeout(resolve, 1500))
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(2)
})
test('query a bunch of events and cancel on eose', async () => {
let events = new Set<string>()
await new Promise<void>(resolve => {
pool.subscribeManyEose(
[...relays, ...relays, 'wss://relayable.org', 'wss://relay.noswhere.com', 'wss://nothing.com'],
[{ kinds: [0, 1, 2, 3, 4, 5, 6], limit: 40 }],
{
onevent(event) {
events.add(event.id)
},
onclose: resolve as any,
pool.subscribeManyEose(relayURLs, [{ kinds: [0, 1, 2, 3, 4, 5, 6], limit: 40 }], {
onevent(event) {
events.add(event.id)
},
)
onclose: resolve as any,
})
})
expect(events.size).toBeGreaterThan(50)
})
test('querySync()', async () => {
let events = await pool.querySync(
[...relays.slice(0, 2), ...relays.slice(0, 2), 'wss://offchain.pub', 'wss://eden.nostr.land'],
{
authors: authors.slice(0, 2),
kinds: [1],
limit: 2,
},
)
let authors = mockRelays.flatMap(mr => mr.getAuthors())
let events = await pool.querySync(relayURLs, {
authors: authors,
kinds: [1],
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]],
})

45
relay.test.ts
View File

@ -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 relay = new Relay(url)
const mockRelay = new MockRelay()
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 relay = await Relay.connect(url)
const mockRelay = new MockRelay()
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(url)
const relay = new Relay(mockRelay.getUrl())
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()
},
},

198
test-helpers.ts
View File

@ -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
export function newMockRelay(): { url: string; authors: string[]; ids: string[] } {
serial++
const url = `wss://mock.relay.url/${serial}`
const relay = new Server(url)
const secretKeys = [generateSecretKey(), generateSecretKey(), generateSecretKey(), generateSecretKey()]
const preloadedEvents = secretKeys.map(sk =>
finalizeEvent(
{
kind: 1,
content: '',
created_at: Math.floor(Date.now() / 1000),
tags: [],
},
sk,
),
)
constructor(url?: string | undefined) {
this._url = url ?? `wss://random.mock.relay/${Math.floor(Math.random() * 10000)}`
this._server = new Server(this._url)
this._secretKeys = [generateSecretKey(), generateSecretKey(), generateSecretKey(), generateSecretKey()]
this._preloadedEvents = this._secretKeys.map(sk =>
finalizeEvent(
{
kind: 1,
content: '',
created_at: Math.floor(Date.now() / 1000),
tags: [],
},
sk,
),
)
relay.on('connection', (conn: any) => {
let subs: { [subId: string]: { conn: any; filters: Filter[] } } = {}
this._server.on('connection', (conn: any) => {
let subs: { [subId: string]: { conn: any; filters: Filter[] } } = {}
conn.on('message', (message: string) => {
const data = JSON.parse(message)
switch (data[0]) {
case 'REQ': {
let subId = data[1]
let filters = data.slice(2)
subs[subId] = { conn, filters }
conn.on('message', (message: string) => {
const data = JSON.parse(message)
preloadedEvents.forEach(event => {
conn.send(JSON.stringify(['EVENT', subId, event]))
})
switch (data[0]) {
case 'REQ': {
let subId = data[1]
let filters = data.slice(2)
subs[subId] = { conn, filters }
filters.forEach((filter: Filter) => {
const kinds = filter.kinds?.length ? filter.kinds : [1]
kinds.forEach(kind => {
secretKeys.forEach(sk => {
const event = finalizeEvent(
{
kind,
content: '',
created_at: Math.floor(Date.now() / 1000),
tags: [],
},
sk,
)
conn.send(JSON.stringify(['EVENT', subId, event]))
this._preloadedEvents.forEach(event => {
conn.send(JSON.stringify(['EVENT', subId, event]))
})
filters.forEach((filter: Filter) => {
const kinds = filter.kinds?.length ? filter.kinds : [1]
kinds.forEach(kind => {
this._secretKeys.forEach(sk => {
const event = finalizeEvent(
{
kind,
content: '',
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()
}
}