psf-bch-api 1.1.0

package/test/unit/entities/event-unit.js

@@ -0,0 +1,139 @@
+/*
+  Unit tests for the Event entity.
+*/
+
+// npm libraries
+import { assert } from 'chai'
+
+// Mocking data libraries
+import {
+  mockKind0Event,
+  mockKind1Event,
+  mockKind3Event,
+  mockKind7Event,
+  mockInvalidEventMissingId,
+  mockInvalidEventWrongIdLength,
+  mockInvalidEventMissingPubkey,
+  mockInvalidEventWrongPubkeyLength,
+  mockInvalidEventMissingCreatedAt,
+  mockInvalidEventWrongCreatedAtType,
+  mockInvalidEventMissingKind,
+  mockInvalidEventKindOutOfRange,
+  mockInvalidEventMissingSig,
+  mockInvalidEventWrongSigLength,
+  mockInvalidEventTagsNotArray
+} from '../mocks/event-mocks.js'
+
+// Unit under test
+import Event from '../../../src/entities/event.js'
+
+describe('#event.js', () => {
+  describe('#isValid()', () => {
+    it('should return true for valid kind 0 event', () => {
+      const event = new Event(mockKind0Event)
+      assert.isTrue(event.isValid())
+    })
+
+    it('should return true for valid kind 1 event', () => {
+      const event = new Event(mockKind1Event)
+      assert.isTrue(event.isValid())
+    })
+
+    it('should return true for valid kind 3 event', () => {
+      const event = new Event(mockKind3Event)
+      assert.isTrue(event.isValid())
+    })
+
+    it('should return true for valid kind 7 event', () => {
+      const event = new Event(mockKind7Event)
+      assert.isTrue(event.isValid())
+    })
+
+    it('should return false for event missing id', () => {
+      const event = new Event(mockInvalidEventMissingId)
+      assert.isFalse(event.isValid())
+    })
+
+    it('should return false for event with wrong id length', () => {
+      const event = new Event(mockInvalidEventWrongIdLength)
+      assert.isFalse(event.isValid())
+    })
+
+    it('should return false for event missing pubkey', () => {
+      const event = new Event(mockInvalidEventMissingPubkey)
+      assert.isFalse(event.isValid())
+    })
+
+    it('should return false for event with wrong pubkey length', () => {
+      const event = new Event(mockInvalidEventWrongPubkeyLength)
+      assert.isFalse(event.isValid())
+    })
+
+    it('should return false for event missing created_at', () => {
+      const event = new Event(mockInvalidEventMissingCreatedAt)
+      assert.isFalse(event.isValid())
+    })
+
+    it('should return false for event with wrong created_at type', () => {
+      const event = new Event(mockInvalidEventWrongCreatedAtType)
+      assert.isFalse(event.isValid())
+    })
+
+    it('should return false for event missing kind', () => {
+      const event = new Event(mockInvalidEventMissingKind)
+      assert.isFalse(event.isValid())
+    })
+
+    it('should return false for event with kind out of range', () => {
+      const event = new Event(mockInvalidEventKindOutOfRange)
+      assert.isFalse(event.isValid())
+    })
+
+    it('should return false for event missing sig', () => {
+      const event = new Event(mockInvalidEventMissingSig)
+      assert.isFalse(event.isValid())
+    })
+
+    it('should return false for event with wrong sig length', () => {
+      const event = new Event(mockInvalidEventWrongSigLength)
+      assert.isFalse(event.isValid())
+    })
+
+    it('should return false for event with tags not an array', () => {
+      const event = new Event(mockInvalidEventTagsNotArray)
+      assert.isFalse(event.isValid())
+    })
+  })
+
+  describe('#toJSON()', () => {
+    it('should serialize event to JSON correctly', () => {
+      const event = new Event(mockKind1Event)
+      const json = event.toJSON()
+
+      assert.property(json, 'id')
+      assert.property(json, 'pubkey')
+      assert.property(json, 'created_at')
+      assert.property(json, 'kind')
+      assert.property(json, 'tags')
+      assert.property(json, 'content')
+      assert.property(json, 'sig')
+
+      assert.equal(json.id, mockKind1Event.id)
+      assert.equal(json.pubkey, mockKind1Event.pubkey)
+      assert.equal(json.created_at, mockKind1Event.created_at)
+      assert.equal(json.kind, mockKind1Event.kind)
+      assert.deepEqual(json.tags, mockKind1Event.tags)
+      assert.equal(json.content, mockKind1Event.content)
+      assert.equal(json.sig, mockKind1Event.sig)
+    })
+
+    it('should serialize event with tags correctly', () => {
+      const event = new Event(mockKind3Event)
+      const json = event.toJSON()
+
+      assert.isArray(json.tags)
+      assert.equal(json.tags.length, 1)
+      assert.deepEqual(json.tags, mockKind3Event.tags)
+    })
+  })
+})

package/test/unit/mocks/controller-mocks.js

@@ -0,0 +1,98 @@
+/*
+  Mock Express request/response objects for controller unit tests.
+*/
+
+// Mock Express request object
+export function createMockRequest (overrides = {}) {
+  return {
+    body: {},
+    params: {},
+    query: {},
+    method: 'GET',
+    path: '/',
+    ...overrides
+  }
+}
+
+// Mock Express response object
+export function createMockResponse () {
+  const res = {
+    statusCode: 200,
+    jsonData: null,
+    statusValue: null,
+    headers: {},
+    writeData: [],
+    endCalled: false,
+    writable: true, // Stream is writable by default
+    destroyed: false, // Stream is not destroyed by default
+    closed: false, // Stream is not closed by default
+    eventHandlers: {} // Store event handlers
+  }
+
+  res.status = function (code) {
+    res.statusCode = code
+    res.statusValue = code
+    return res
+  }
+
+  res.json = function (data) {
+    res.jsonData = data
+    return res
+  }
+
+  res.setHeader = function (name, value) {
+    res.headers[name] = value
+    return res
+  }
+
+  res.write = function (data) {
+    res.writeData.push(data)
+    return true
+  }
+
+  res.end = function () {
+    res.endCalled = true
+    return res
+  }
+
+  res.on = function (event, callback) {
+    // Store event handlers for different event types
+    if (!res.eventHandlers[event]) {
+      res.eventHandlers[event] = []
+    }
+    res.eventHandlers[event].push(callback)
+
+    // For backward compatibility with existing tests
+    if (event === 'close') {
+      res.closeCallback = callback
+    }
+
+    return res
+  }
+
+  // Helper to trigger an event (useful for testing)
+  res.trigger = function (event, ...args) {
+    if (res.eventHandlers[event]) {
+      for (const handler of res.eventHandlers[event]) {
+        handler(...args)
+      }
+    }
+  }
+
+  return res
+}
+
+// Helper to create a mock request with body
+export function createMockRequestWithBody (body) {
+  return createMockRequest({ body })
+}
+
+// Helper to create a mock request with params
+export function createMockRequestWithParams (params) {
+  return createMockRequest({ params })
+}
+
+// Helper to create a mock request with query
+export function createMockRequestWithQuery (query) {
+  return createMockRequest({ query })
+}

package/test/unit/mocks/event-mocks.js

@@ -0,0 +1,194 @@
+/*
+  Mock event data for unit tests.
+  Contains mock Nostr events for various event kinds.
+*/
+
+// Alice's public key from examples
+const alicePubKey = '2c7e76c0f8dc1dca9d0197c7d19be580a8d074ccada6a2f6ebe056ae41092e92'
+const bobPubKey = 'b'.repeat(64)
+
+// Valid event ID (64 hex chars)
+const validEventId = 'd09b4c5da59be3cd2768aa53fa78b77bf4859084c94f3bf26d401f004a9c8167'
+// Valid signature (128 hex chars)
+const validSig = 'a'.repeat(128)
+
+// Kind 0: Profile metadata event
+const mockKind0Event = {
+  id: validEventId,
+  pubkey: alicePubKey,
+  created_at: Math.floor(Date.now() / 1000),
+  kind: 0,
+  tags: [],
+  content: JSON.stringify({
+    name: 'Alice',
+    about: 'Hello, I am Alice!',
+    picture: 'https://example.com/alice.jpg'
+  }),
+  sig: validSig
+}
+
+// Kind 1: Text post event
+const mockKind1Event = {
+  id: validEventId,
+  pubkey: alicePubKey,
+  created_at: Math.floor(Date.now() / 1000),
+  kind: 1,
+  tags: [],
+  content: 'This is a test message',
+  sig: validSig
+}
+
+// Kind 3: Follow list event
+const mockKind3Event = {
+  id: validEventId,
+  pubkey: alicePubKey,
+  created_at: Math.floor(Date.now() / 1000),
+  kind: 3,
+  tags: [
+    ['p', bobPubKey, 'wss://nostr-relay.psfoundation.info', 'bob']
+  ],
+  content: '',
+  sig: validSig
+}
+
+// Kind 7: Reaction/like event
+const mockKind7Event = {
+  id: validEventId,
+  pubkey: bobPubKey,
+  created_at: Math.floor(Date.now() / 1000),
+  kind: 7,
+  tags: [
+    ['e', validEventId, 'wss://nostr-relay.psfoundation.info'],
+    ['p', alicePubKey, 'wss://nostr-relay.psfoundation.info']
+  ],
+  content: '+',
+  sig: validSig
+}
+
+// Invalid events for testing validation
+const mockInvalidEventMissingId = {
+  pubkey: alicePubKey,
+  created_at: Math.floor(Date.now() / 1000),
+  kind: 1,
+  tags: [],
+  content: 'Test',
+  sig: validSig
+}
+
+const mockInvalidEventWrongIdLength = {
+  id: 'short',
+  pubkey: alicePubKey,
+  created_at: Math.floor(Date.now() / 1000),
+  kind: 1,
+  tags: [],
+  content: 'Test',
+  sig: validSig
+}
+
+const mockInvalidEventMissingPubkey = {
+  id: validEventId,
+  created_at: Math.floor(Date.now() / 1000),
+  kind: 1,
+  tags: [],
+  content: 'Test',
+  sig: validSig
+}
+
+const mockInvalidEventWrongPubkeyLength = {
+  id: validEventId,
+  pubkey: 'short',
+  created_at: Math.floor(Date.now() / 1000),
+  kind: 1,
+  tags: [],
+  content: 'Test',
+  sig: validSig
+}
+
+const mockInvalidEventMissingCreatedAt = {
+  id: validEventId,
+  pubkey: alicePubKey,
+  kind: 1,
+  tags: [],
+  content: 'Test',
+  sig: validSig
+}
+
+const mockInvalidEventWrongCreatedAtType = {
+  id: validEventId,
+  pubkey: alicePubKey,
+  created_at: 'not-a-number',
+  kind: 1,
+  tags: [],
+  content: 'Test',
+  sig: validSig
+}
+
+const mockInvalidEventMissingKind = {
+  id: validEventId,
+  pubkey: alicePubKey,
+  created_at: Math.floor(Date.now() / 1000),
+  tags: [],
+  content: 'Test',
+  sig: validSig
+}
+
+const mockInvalidEventKindOutOfRange = {
+  id: validEventId,
+  pubkey: alicePubKey,
+  created_at: Math.floor(Date.now() / 1000),
+  kind: 70000, // Out of range (0-65535)
+  tags: [],
+  content: 'Test',
+  sig: validSig
+}
+
+const mockInvalidEventMissingSig = {
+  id: validEventId,
+  pubkey: alicePubKey,
+  created_at: Math.floor(Date.now() / 1000),
+  kind: 1,
+  tags: [],
+  content: 'Test'
+}
+
+const mockInvalidEventWrongSigLength = {
+  id: validEventId,
+  pubkey: alicePubKey,
+  created_at: Math.floor(Date.now() / 1000),
+  kind: 1,
+  tags: [],
+  content: 'Test',
+  sig: 'short'
+}
+
+const mockInvalidEventTagsNotArray = {
+  id: validEventId,
+  pubkey: alicePubKey,
+  created_at: Math.floor(Date.now() / 1000),
+  kind: 1,
+  tags: 'not-an-array',
+  content: 'Test',
+  sig: validSig
+}
+
+export {
+  mockKind0Event,
+  mockKind1Event,
+  mockKind3Event,
+  mockKind7Event,
+  mockInvalidEventMissingId,
+  mockInvalidEventWrongIdLength,
+  mockInvalidEventMissingPubkey,
+  mockInvalidEventWrongPubkeyLength,
+  mockInvalidEventMissingCreatedAt,
+  mockInvalidEventWrongCreatedAtType,
+  mockInvalidEventMissingKind,
+  mockInvalidEventKindOutOfRange,
+  mockInvalidEventMissingSig,
+  mockInvalidEventWrongSigLength,
+  mockInvalidEventTagsNotArray,
+  alicePubKey,
+  bobPubKey,
+  validEventId,
+  validSig
+}

package/test/unit/use-cases/full-node-blockchain-use-cases-unit.js

@@ -0,0 +1,137 @@
+/*
+  Unit tests for BlockchainUseCases.
+*/
+
+import { assert } from 'chai'
+import sinon from 'sinon'
+
+import BlockchainUseCases from '../../../src/use-cases/full-node-blockchain-use-cases.js'
+
+describe('#full-node-blockchain-use-cases.js', () => {
+  let sandbox
+  let mockAdapters
+  let uut
+
+  const createAdapters = () => {
+    return {
+      fullNode: {
+        call: sandbox.stub()
+      }
+    }
+  }
+
+  beforeEach(() => {
+    sandbox = sinon.createSandbox()
+    mockAdapters = createAdapters()
+    uut = new BlockchainUseCases({ adapters: mockAdapters })
+  })
+
+  afterEach(() => {
+    sandbox.restore()
+  })
+
+  describe('#constructor()', () => {
+    it('should require adapters', () => {
+      assert.throws(() => {
+        // eslint-disable-next-line no-new
+        new BlockchainUseCases()
+      }, /Adapters instance required/)
+    })
+
+    it('should require full node adapter', () => {
+      assert.throws(() => {
+        // eslint-disable-next-line no-new
+        new BlockchainUseCases({ adapters: {} })
+      }, /Full node adapter required/)
+    })
+  })
+
+  describe('#getBestBlockHash()', () => {
+    it('should call full node adapter without parameters', async () => {
+      mockAdapters.fullNode.call.resolves('hash')
+
+      const result = await uut.getBestBlockHash()
+
+      assert.equal(result, 'hash')
+      assert.isTrue(mockAdapters.fullNode.call.calledOnceWithExactly('getbestblockhash'))
+    })
+  })
+
+  describe('#getBlockHeaders()', () => {
+    it('should call adapter for each hash and return aggregated result', async () => {
+      const hashes = ['a'.repeat(64), 'b'.repeat(64)]
+      mockAdapters.fullNode.call
+        .onFirstCall().resolves('header-1')
+        .onSecondCall().resolves('header-2')
+
+      const result = await uut.getBlockHeaders({ hashes, verbose: true })
+
+      assert.deepEqual(result, ['header-1', 'header-2'])
+      assert.isTrue(
+        mockAdapters.fullNode.call.calledWithExactly(
+          'getblockheader',
+          [hashes[0], true],
+          `getblockheader-${hashes[0]}`
+        )
+      )
+      assert.isTrue(
+        mockAdapters.fullNode.call.calledWithExactly(
+          'getblockheader',
+          [hashes[1], true],
+          `getblockheader-${hashes[1]}`
+        )
+      )
+    })
+
+    it('should rethrow errors from adapter', async () => {
+      const hashes = ['a'.repeat(64)]
+      mockAdapters.fullNode.call.rejects(new Error('failure'))
+
+      try {
+        await uut.getBlockHeaders({ hashes })
+        assert.fail('Unexpected success')
+      } catch (err) {
+        assert.equal(err.message, 'failure')
+      }
+    })
+  })
+
+  describe('#getTxOut()', () => {
+    it('should pass parameters to full node call', async () => {
+      mockAdapters.fullNode.call.resolves({ value: 1 })
+
+      const result = await uut.getTxOut({
+        txid: 'txid',
+        n: 0,
+        includeMempool: true
+      })
+
+      assert.deepEqual(result, { value: 1 })
+      assert.isTrue(
+        mockAdapters.fullNode.call.calledOnceWithExactly(
+          'gettxout',
+          ['txid', 0, true]
+        )
+      )
+    })
+  })
+
+  describe('#verifyTxOutProofs()', () => {
+    it('should call adapter for each proof and return aggregated results', async () => {
+      const proofs = ['proof-1', 'proof-2']
+      mockAdapters.fullNode.call.onFirstCall().resolves(['txid-1'])
+      mockAdapters.fullNode.call.onSecondCall().resolves(['txid-2'])
+
+      const result = await uut.verifyTxOutProofs({ proofs })
+
+      assert.deepEqual(result, [['txid-1'], ['txid-2']])
+      assert.isTrue(
+        mockAdapters.fullNode.call.calledWithExactly(
+          'verifytxoutproof',
+          ['proof-1'],
+          `verifytxoutproof-${proofs[0].slice(0, 16)}`
+        )
+      )
+    })
+  })
+})