feat: add schema, factory, handler, and repository tests

Author: a-khushal

test/unit/factories/message-handler-factory.spec.ts

@@ -6,6 +6,7 @@ import { Event } from '../../../src/@types/event'
 import { EventMessageHandler } from '../../../src/handlers/event-message-handler'
 import { IWebSocketAdapter } from '../../../src/@types/adapters'
 import { messageHandlerFactory } from '../../../src/factories/message-handler-factory'
+import { CountMessageHandler } from '../../../src/handlers/count-message-handler'
 import { SubscribeMessageHandler } from '../../../src/handlers/subscribe-message-handler'
 import { UnsubscribeMessageHandler } from '../../../src/handlers/unsubscribe-message-handler'
 import * as cacheModule from '../../../src/cache/client'
@@ -67,6 +68,12 @@ describe('messageHandlerFactory', () => {
     expect(factory([message, adapter])).to.be.an.instanceOf(UnsubscribeMessageHandler)
   })
 
+  it('returns CountMessageHandler when given a COUNT message', () => {
+    message = [MessageType.COUNT, 'q1', {}] as any
+
+    expect(factory([message, adapter])).to.be.an.instanceOf(CountMessageHandler)
+  })
+
   it('throws when given an invalid message', () => {
     message = [] as any
 

test/unit/handlers/count-message-handler.spec.ts

@@ -0,0 +1,93 @@
+import chai from 'chai'
+import EventEmitter from 'events'
+import sinon from 'sinon'
+import sinonChai from 'sinon-chai'
+
+import { IWebSocketAdapter } from '../../../src/@types/adapters'
+import { MessageType } from '../../../src/@types/messages'
+import { IEventRepository } from '../../../src/@types/repositories'
+import { Settings } from '../../../src/@types/settings'
+import { WebSocketAdapterEvent } from '../../../src/constants/adapter'
+import { CountMessageHandler } from '../../../src/handlers/count-message-handler'
+
+chai.use(sinonChai)
+const { expect } = chai
+
+describe('CountMessageHandler', () => {
+  let webSocket: IWebSocketAdapter
+  let handler: CountMessageHandler
+  let eventRepository: IEventRepository
+  let onMessageStub: sinon.SinonStub
+  let sandbox: sinon.SinonSandbox
+
+  beforeEach(() => {
+    sandbox = sinon.createSandbox()
+    eventRepository = {
+      countByFilters: sandbox.stub().resolves(7),
+    } as any
+
+    webSocket = new EventEmitter() as any
+    onMessageStub = sandbox.stub()
+    webSocket.on(WebSocketAdapterEvent.Message, onMessageStub)
+
+    handler = new CountMessageHandler(webSocket, eventRepository, () => ({
+      limits: {
+        client: {
+          subscription: {
+            maxFilters: 10,
+            maxSubscriptionIdLength: 256,
+          },
+        },
+      },
+    }) as Settings)
+  })
+
+  afterEach(() => {
+    webSocket.removeAllListeners()
+    sandbox.restore()
+  })
+
+  it('emits COUNT message with count on success', async () => {
+    const message = [MessageType.COUNT, 'q1', {}] as any
+
+    await handler.handleMessage(message)
+
+    expect(eventRepository.countByFilters).to.have.been.calledOnceWithExactly([{}])
+    expect(onMessageStub).to.have.been.calledOnceWithExactly([MessageType.COUNT, 'q1', { count: 7 }])
+  })
+
+  it('emits CLOSED message when request is rejected', async () => {
+    handler = new CountMessageHandler(webSocket, eventRepository, () => ({
+      limits: {
+        client: {
+          subscription: {
+            maxFilters: 1,
+            maxSubscriptionIdLength: 256,
+          },
+        },
+      },
+    }) as Settings)
+
+    const message = [MessageType.COUNT, 'q1', { kinds: [1] }, { kinds: [2] }] as any
+
+    await handler.handleMessage(message)
+
+    expect(eventRepository.countByFilters).to.not.have.been.called
+    expect(onMessageStub).to.have.been.calledOnce
+    expect(onMessageStub.firstCall.args[0][0]).to.equal(MessageType.CLOSED)
+    expect(onMessageStub.firstCall.args[0][1]).to.equal('q1')
+  })
+
+  it('emits CLOSED message when repository fails', async () => {
+    (eventRepository.countByFilters as sinon.SinonStub).rejects(new Error('boom'))
+    const message = [MessageType.COUNT, 'q1', {}] as any
+
+    await handler.handleMessage(message)
+
+    expect(onMessageStub).to.have.been.calledOnceWithExactly([
+      MessageType.CLOSED,
+      'q1',
+      'error: unable to count events',
+    ])
+  })
+})

test/unit/repositories/event-repository.spec.ts

@@ -417,6 +417,71 @@ describe('EventRepository', () => {
     })
   })
 
+  describe('.countByFilters', () => {
+    it('throws error if filters is empty', async () => {
+      try {
+        await repository.countByFilters([])
+        expect.fail('Expected countByFilters to throw')
+      } catch (error) {
+        expect((error as Error).message).to.equal('Filters cannot be empty')
+      }
+    })
+
+    it('returns count value from query result', async () => {
+      sandbox.stub(rrDbClient, 'from').returns({
+        countDistinct: () => ({
+          first: async () => ({ count: '42' }),
+        }),
+      } as any)
+
+      const result = await repository.countByFilters([{}])
+
+      expect(result).to.equal(42)
+    })
+
+    it('builds union query when there are multiple filters', async () => {
+      const fromStub = sandbox.stub(rrDbClient, 'from').returns({
+        countDistinct: () => ({
+          first: async () => ({ count: '1' }),
+        }),
+      } as any)
+
+      await repository.countByFilters([{ kinds: [1] }, { authors: ['22e804d26ed16b68db5259e78449e96dab5d464c8f470bda3eb1a70467f2c793'] }])
+
+      const sql = fromStub.firstCall.args[0].toString()
+      expect(sql).to.include(' union ')
+    })
+
+    it('joins tags table for generic tag filters', async () => {
+      const fromStub = sandbox.stub(rrDbClient, 'from').returns({
+        countDistinct: () => ({
+          first: async () => ({ count: '1' }),
+        }),
+      } as any)
+
+      await repository.countByFilters([{ '#e': ['aaaaaa'] } as any])
+
+      const sql = fromStub.firstCall.args[0].toString()
+      expect(sql).to.include('left join "event_tags"')
+      expect(sql).to.include('event_tags.tag_name')
+    })
+
+    it('filters out deleted and expired events', async () => {
+      const fromStub = sandbox.stub(rrDbClient, 'from').returns({
+        countDistinct: () => ({
+          first: async () => ({ count: '1' }),
+        }),
+      } as any)
+
+      await repository.countByFilters([{ kinds: [1] }])
+
+      const sql = fromStub.firstCall.args[0].toString()
+      expect(sql).to.include('"events"."deleted_at" is null')
+      expect(sql).to.include('"events"."expires_at" is null')
+      expect(sql).to.include('"events"."expires_at" >')
+    })
+  })
+
   describe('.create', () => {
     let insertStub: sinon.SinonStub
     beforeEach(() => {

test/unit/schemas/message-schema.spec.ts

@@ -112,5 +112,53 @@ describe('NIP-01', () => {
         expect(result).to.have.property('error').that.is.not.undefined
       })
     })
+
+    describe('COUNT', () => {
+      beforeEach(() => {
+        message = [
+          'COUNT',
+          'id',
+          {
+            ids: ['aaaa', 'bbbb', 'cccc'],
+            authors: ['aaaa', 'bbbb', 'cccc'],
+            kinds: [0, 1, 2, 3],
+            since: 1000,
+            until: 1000,
+            limit: 100,
+            '#e': ['aa', 'bb', 'cc'],
+            '#p': ['dd', 'ee', 'ff'],
+            '#r': ['00', '11', '22'],
+          },
+        ] as any
+      })
+
+      it('returns same message if valid', () => {
+        const result = validateSchema(messageSchema)(message)
+        expect(result.error).to.be.undefined
+        expect(result).to.have.deep.property('value', message)
+      })
+
+      it('returns error if query ID is missing', () => {
+        message[1] = null
+
+        const result = validateSchema(messageSchema)(message)
+        expect(result).to.have.property('error').that.is.not.undefined
+      })
+
+      it('returns error if filter is missing', () => {
+        ;(message as any[]).splice(2, 1)
+
+        const result = validateSchema(messageSchema)(message)
+        expect(result).to.have.property('error').that.is.not.undefined
+      })
+
+      it('returns error if there are too many filters', () => {
+        ;(message as any[]).splice(2, 1)
+        ;(message as any[]).push(...range(0, 11).map(() => ({})))
+
+        const result = validateSchema(messageSchema)(message)
+        expect(result).to.have.property('error').that.is.not.undefined
+      })
+    })
   })
 })