mirror of
https://github.com/Cameri/nostream.git
synced 2025-06-11 17:31:36 +02:00
143 lines
4.7 KiB
TypeScript
143 lines
4.7 KiB
TypeScript
import chai from 'chai'
|
|
import chaiAsPromised from 'chai-as-promised'
|
|
import Sinon from 'sinon'
|
|
|
|
chai.use(chaiAsPromised)
|
|
|
|
import { DatabaseClient } from '../../../../src/@types/base'
|
|
import { DeleteEventStrategy } from '../../../../src/handlers/event-strategies/delete-event-strategy'
|
|
import { Event } from '../../../../src/@types/event'
|
|
import { EventRepository } from '../../../../src/repositories/event-repository'
|
|
import { EventTags } from '../../../../src/constants/base'
|
|
import { IEventRepository } from '../../../../src/@types/repositories'
|
|
import { IEventStrategy } from '../../../../src/@types/message-handlers'
|
|
import { IWebSocketAdapter } from '../../../../src/@types/adapters'
|
|
import { MessageType } from '../../../../src/@types/messages'
|
|
import { WebSocketAdapterEvent } from '../../../../src/constants/adapter'
|
|
|
|
const { expect } = chai
|
|
|
|
describe('DeleteEventStrategy', () => {
|
|
const event: Event = {
|
|
id: 'id',
|
|
pubkey: 'pubkey',
|
|
tags: [
|
|
[EventTags.Event, '00000000'.repeat(8)],
|
|
[EventTags.Event, 'ffffffff'.repeat(8)],
|
|
],
|
|
} as any
|
|
let webSocket: IWebSocketAdapter
|
|
let eventRepository: IEventRepository
|
|
|
|
let webSocketEmitStub: Sinon.SinonStub
|
|
let eventRepositoryCreateStub: Sinon.SinonStub
|
|
let eventRepositoryDeleteByPubkeyAndIdsStub: Sinon.SinonStub
|
|
let eventRepositoryInsertStubsStub: Sinon.SinonStub
|
|
|
|
let strategy: IEventStrategy<Event, Promise<void>>
|
|
|
|
let sandbox: Sinon.SinonSandbox
|
|
|
|
beforeEach(() => {
|
|
sandbox = Sinon.createSandbox()
|
|
|
|
eventRepositoryCreateStub = sandbox.stub(EventRepository.prototype, 'create')
|
|
eventRepositoryDeleteByPubkeyAndIdsStub = sandbox.stub(EventRepository.prototype, 'deleteByPubkeyAndIds')
|
|
eventRepositoryInsertStubsStub = sandbox.stub(EventRepository.prototype, 'insertStubs')
|
|
|
|
webSocketEmitStub = sandbox.stub()
|
|
webSocket = {
|
|
emit: webSocketEmitStub,
|
|
} as any
|
|
const masterClient: DatabaseClient = {} as any
|
|
const readReplicaClient: DatabaseClient = {} as any
|
|
eventRepository = new EventRepository(masterClient, readReplicaClient)
|
|
|
|
strategy = new DeleteEventStrategy(webSocket, eventRepository)
|
|
})
|
|
|
|
afterEach(() => {
|
|
sandbox.restore()
|
|
})
|
|
|
|
describe('execute', () => {
|
|
it('creates event', async () => {
|
|
await strategy.execute(event)
|
|
|
|
expect(eventRepositoryCreateStub).to.have.been.calledOnceWithExactly(event)
|
|
})
|
|
|
|
it('inserts stubs', async () => {
|
|
await strategy.execute(event)
|
|
|
|
expect(eventRepositoryInsertStubsStub).to.have.been.calledOnceWithExactly(
|
|
event.pubkey,
|
|
[
|
|
'0000000000000000000000000000000000000000000000000000000000000000',
|
|
'ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff',
|
|
]
|
|
)
|
|
})
|
|
|
|
it('deletes events if it has e tags', async () => {
|
|
await strategy.execute(event)
|
|
|
|
expect(eventRepositoryDeleteByPubkeyAndIdsStub).to.have.been.calledOnceWithExactly(
|
|
event.pubkey,
|
|
[
|
|
'0000000000000000000000000000000000000000000000000000000000000000',
|
|
'ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff',
|
|
]
|
|
)
|
|
})
|
|
|
|
it('does not delete events if there are no e tags', async () => {
|
|
event.tags = []
|
|
|
|
await strategy.execute(event)
|
|
|
|
expect(eventRepositoryDeleteByPubkeyAndIdsStub).not.to.have.been.called
|
|
})
|
|
|
|
it('broadcast event if created', async () => {
|
|
eventRepositoryCreateStub.resolves(1)
|
|
|
|
await strategy.execute(event)
|
|
|
|
expect(eventRepositoryCreateStub).to.have.been.calledOnceWithExactly(event)
|
|
expect(webSocketEmitStub).to.have.been.calledTwice
|
|
expect(webSocketEmitStub).to.have.been.calledWithExactly(
|
|
WebSocketAdapterEvent.Message,
|
|
[MessageType.OK, 'id', true, '']
|
|
)
|
|
expect(webSocketEmitStub).to.have.been.calledWithExactly(
|
|
WebSocketAdapterEvent.Broadcast,
|
|
event
|
|
)
|
|
})
|
|
|
|
it('does not broadcast event if duplicate', async () => {
|
|
eventRepositoryCreateStub.resolves(0)
|
|
|
|
await strategy.execute(event)
|
|
|
|
expect(webSocketEmitStub).to.have.been.calledOnceWithExactly(
|
|
WebSocketAdapterEvent.Message,
|
|
[MessageType.OK, 'id', true, 'duplicate:']
|
|
)
|
|
})
|
|
|
|
it('rejects if unable to create event', async () => {
|
|
const error = new Error()
|
|
eventRepositoryCreateStub.rejects(error)
|
|
|
|
await expect(strategy.execute(event)).to.eventually.be.rejectedWith(error)
|
|
|
|
expect(eventRepositoryCreateStub).to.have.been.calledOnceWithExactly(event)
|
|
expect(eventRepositoryDeleteByPubkeyAndIdsStub).not.to.have.been.called
|
|
expect(eventRepositoryInsertStubsStub).to.not.have.been.called
|
|
expect(webSocketEmitStub).not.to.have.been.called
|
|
})
|
|
})
|
|
})
|