libp2r2p 0.0.2 → 0.1.0

package/tests/queries.test.js

@@ -1,101 +0,0 @@
-import { afterEach, test } from 'node:test'
-import assert from 'node:assert/strict'
-import { generateSecretKey } from 'nostr-tools'
-
-import TestSigner from './helpers/test-signer.js'
-import { bytesToHex } from '../base16/index.js'
-import { makeContentKeyEvent } from '../content-key/event/index.js'
-import { getIykcProofs, clearContentKeyCache } from '../content-key/services/iykc-proof.js'
-import { cacheRelayListEvent, clearRelayQueryCache, getRelaysByPubkey, subscribeRelayListUpdates } from '../relay/services/query.js'
-import { pickRelaysForPubkeys } from '../relay/helpers/routing.js'
-
-afterEach(() => {
-  clearRelayQueryCache()
-  clearContentKeyCache()
-  TestSigner.releaseAll()
-})
-
-function signer () {
-  return TestSigner.getOrCreate(bytesToHex(generateSecretKey()))
-}
-
-function relayListEvent (pubkey, createdAt, tags) {
-  return { kind: 10002, pubkey, created_at: createdAt, tags, content: '' }
-}
-
-test('cacheRelayListEvent tracks newer relay-list events and exposes changed sets', () => {
-  const first = cacheRelayListEvent(relayListEvent('alice', 1, [['r', 'wss://one.example']]))
-  const older = cacheRelayListEvent(relayListEvent('alice', 1, [['r', 'wss://two.example']]))
-  const newer = cacheRelayListEvent(relayListEvent('alice', 2, [['r', 'wss://two.example', 'write']]))
-
-  assert.deepEqual(first.relays, { read: ['wss://one.example'], write: ['wss://one.example'] })
-  assert.equal(older, null)
-  assert.deepEqual(newer.previousRelays, { read: ['wss://one.example'], write: ['wss://one.example'] })
-  assert.deepEqual(newer.relays, { read: [], write: ['wss://two.example'] })
-  assert.deepEqual(newer.changes, { read: true, write: true, both: true })
-})
-
-test('pickRelaysForPubkeys covers pubkeys with shared relay preference', () => {
-  const picked = pickRelaysForPubkeys(['alice', 'bob'], {
-    alice: { write: ['wss://shared.example', 'wss://alice.example'] },
-    bob: { write: ['wss://shared.example', 'wss://bob.example'] }
-  }, { maxPerPubkey: 1 })
-
-  assert.deepEqual([...picked.entries()], [['wss://shared.example', ['alice', 'bob']]])
-})
-
-test('getRelaysByPubkey fetches latest relay lists and falls back when absent', async () => {
-  const calls = []
-  const relays = await getRelaysByPubkey(['alice', 'bob'], {
-    _getEvents: async (filter, relayUrls, options) => {
-      calls.push({ filter, relayUrls })
-      assert.deepEqual(options, { timeout: 5000, timeoutAfterFirstEose: null })
-      return { result: [relayListEvent('alice', 9, [['r', 'wss://alice.example', 'write']])] }
-    }
-  })
-
-  assert.equal(calls.length, 1)
-  assert.deepEqual(calls[0].filter.authors, ['alice', 'bob'])
-  assert.deepEqual(relays.alice, { read: [], write: ['wss://alice.example'] })
-  assert.deepEqual(relays.bob.write.slice(0, 2), ['wss://relay.44billion.net', 'wss://nos.lol'])
-})
-
-test('getIykcProofs finds latest content-key events through relay routing', async () => {
-  const user = signer()
-  const older = signer()
-  const newer = signer()
-  const userPubkey = await user.getPublicKey()
-  const olderEvent = await makeContentKeyEvent({ userSigner: user, contentKeySigner: older, createdAt: 7 })
-  const newerEvent = await makeContentKeyEvent({ userSigner: user, contentKeySigner: newer, createdAt: 8 })
-
-  const found = await getIykcProofs([userPubkey], {
-    _getRelaysByPubkey: async () => ({ [userPubkey]: { write: ['wss://one.example'] } }),
-    _getEvents: async () => ({ result: [olderEvent, newerEvent] })
-  })
-
-  assert.equal(found[userPubkey].iykcPubkey, await newer.getPublicKey())
-})
-
-test('subscribeRelayListUpdates only reports watched relay-type changes', async () => {
-  const changes = []
-  let aborted = false
-  async function * events (_filter, _relays, { signal }) {
-    signal.addEventListener('abort', () => { aborted = true }, { once: true })
-    yield relayListEvent('alice', 1, [['r', 'wss://read.example', 'read']])
-    yield relayListEvent('alice', 2, [['r', 'wss://write.example', 'write']])
-    await new Promise(resolve => signal.addEventListener('abort', resolve, { once: true }))
-  }
-
-  const stop = subscribeRelayListUpdates(['alice'], {
-    relayType: 'write',
-    onChange: change => changes.push(change),
-    _eventsFeedGenerator: events
-  })
-  await new Promise(resolve => setImmediate(resolve))
-  stop()
-  await new Promise(resolve => setImmediate(resolve))
-
-  assert.equal(changes.length, 1)
-  assert.deepEqual(changes[0].relays, { read: [], write: ['wss://write.example'] })
-  assert.ok(aborted)
-})

package/tests/queue-parity.test.js

@@ -1,105 +0,0 @@
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { IDBFactory } from 'fake-indexeddb'
-import { createQueue as createIdbQueue } from '../idb-queue/index.js'
-import { createQueue as createWebStorageQueue } from '../web-storage-queue/index.js'
-
-const CORE_METHODS = [
-  'enqueue', 'push', 'pop', 'unshift', 'shift', 'items', 'reverseItems',
-  'storedItems', 'reverseStoredItems', 'setAt', 'insertAt', 'insertWhere',
-  'removeAt', 'removeWhere', 'some', 'clear'
-]
-
-function createStorageArea () {
-  const values = new Map()
-  return {
-    getItem: key => values.get(String(key)) ?? null,
-    removeItem: key => { values.delete(String(key)) },
-    setItem: (key, value) => { values.set(String(key), String(value)) }
-  }
-}
-
-async function call (queue, method, ...args) {
-  return queue[method](...args)
-}
-
-async function storedValues (queue) {
-  const values = []
-  for await (const value of queue.storedItems()) values.push(value)
-  return values
-}
-
-async function coreTrace (queue) {
-  const returns = []
-  returns.push(await call(queue, 'push', { value: 'middle' }))
-  returns.push(await call(queue, 'unshift', { value: 'first' }))
-  returns.push(await call(queue, 'push', { value: 'last' }))
-  returns.push(await call(queue, 'setAt', 1, { value: 'MIDDLE' }))
-  returns.push(await call(queue, 'insertAt', 2, { value: 'between' }))
-  const beforeRemoval = await storedValues(queue)
-  const hasBetween = await call(queue, 'some', item => item.value === 'between')
-  await call(queue, 'removeWhere', item => item.value === 'between')
-
-  return {
-    returns,
-    beforeRemoval,
-    hasBetween,
-    afterRemoval: await storedValues(queue),
-    drained: [
-      await call(queue, 'shift'),
-      await call(queue, 'pop'),
-      await call(queue, 'shift'),
-      await call(queue, 'shift')
-    ]
-  }
-}
-
-test('idb queue preserves the web-storage queue core API and semantics', async () => {
-  const webStorageQueue = createWebStorageQueue({
-    prefix: 'web',
-    storageArea: createStorageArea()
-  })
-  const idbQueue = await createIdbQueue({
-    prefix: 'idb',
-    indexedDB: new IDBFactory()
-  })
-
-  assert.deepEqual(Object.keys(webStorageQueue).sort(), [...CORE_METHODS].sort())
-  assert.deepEqual(
-    Object.keys(idbQueue).filter(method => CORE_METHODS.includes(method)).sort(),
-    [...CORE_METHODS].sort()
-  )
-  assert.equal(typeof idbQueue.getBy, 'function')
-  assert.equal(typeof idbQueue.someBy, 'function')
-  assert.equal(typeof idbQueue.removeBy, 'function')
-  assert.equal(typeof idbQueue.storedItemsBy, 'function')
-
-  assert.deepEqual(await coreTrace(idbQueue), await coreTrace(webStorageQueue))
-})
-
-test('queues preserve caller ids without injecting queue positions', async () => {
-  const queues = [
-    createWebStorageQueue({ prefix: 'web', storageArea: createStorageArea() }),
-    await createIdbQueue({ prefix: 'idb', indexedDB: new IDBFactory() })
-  ]
-
-  for (const queue of queues) {
-    await call(queue, 'push', { value: 'generated' })
-    await call(queue, 'push', { id: 'caller-id', value: 'provided' })
-    assert.deepEqual(await call(queue, 'shift'), { value: 'generated' })
-    assert.deepEqual(await call(queue, 'shift'), { id: 'caller-id', value: 'provided' })
-  }
-})
-
-test('both queue types require a prefix and predicate callbacks', async () => {
-  const storageArea = createStorageArea()
-  assert.throws(() => createWebStorageQueue({ storageArea }), /QUEUE_PREFIX_REQUIRED/)
-  await assert.rejects(createIdbQueue({ indexedDB: new IDBFactory() }), /QUEUE_PREFIX_REQUIRED/)
-
-  const webStorageQueue = createWebStorageQueue({ prefix: 'web', storageArea })
-  const idbQueue = await createIdbQueue({ prefix: 'idb', indexedDB: new IDBFactory() })
-  for (const method of ['insertWhere', 'removeWhere', 'some']) {
-    assert.throws(() => webStorageQueue[method](), /QUEUE_PREDICATE_REQUIRED/)
-    await assert.rejects(idbQueue[method](), /QUEUE_PREDICATE_REQUIRED/)
-  }
-})

package/tests/relay-hll.test.js

@@ -1,32 +0,0 @@
-import assert from 'node:assert/strict'
-import { test } from 'node:test'
-import { decodeHll, encodeHll, estimateHllCount, mergeHll } from '../relay/helpers/hll.js'
-
-function registers (entries = {}) {
-  const value = new Uint8Array(256)
-  for (const [index, register] of Object.entries(entries)) value[Number(index)] = register
-  return value
-}
-
-test('HLL helpers validate and normalize NIP-45 register payloads', () => {
-  const value = registers({ 0: 10, 255: 15 })
-  const encoded = encodeHll(value)
-
-  assert.equal(encoded.length, 512)
-  assert.equal(encoded.slice(0, 2), '0a')
-  assert.equal(encoded.slice(-2), '0f')
-  assert.deepEqual(decodeHll(encoded.toUpperCase()), value)
-  assert.equal(decodeHll(''), null)
-  assert.equal(decodeHll('x'.repeat(512)), null)
-  assert.equal(decodeHll('0'.repeat(511)), null)
-})
-
-test('HLL helpers merge registers and estimate cardinality', () => {
-  const target = registers({ 0: 1, 1: 5 })
-  const source = registers({ 0: 4, 2: 3 })
-
-  assert.deepEqual(mergeHll(target, source), registers({ 0: 4, 1: 5, 2: 3 }))
-  assert.equal(estimateHllCount(registers()), 0)
-  assert.equal(estimateHllCount(registers({ 8: 1 })), 1)
-  assert.equal(estimateHllCount(new Uint8Array(256).fill(1)), 367)
-})