feat: add unit tests for stacking events

src/services/storage/handlers/stake.ts

@@ -11,44 +11,28 @@ const handlers = {
   async Staked (event: EventData, { stakeService }: StorageServices): Promise<void> {
     const { user: account, total, token, amount } = event.returnValues
 
-    const stakeData = {
-      total,
-      token,
-      account
-    }
-    await StakeModel.upsert(stakeData)
-    const stake = await StakeModel.findOne({ where: { token } })
-
-    if (!stake) {
-      throw new Error(`Stake for token ${stakeData.token} was not created`)
-    }
+    const stake = await StakeModel.findOne({ where: { token, account } })
 
-    logger.info(`Account ${stake.account} stake amount ${amount}, final balance ${stake.total}`)
+    stake!.total = total
+    await stake!.save()
+    logger.info(`Account ${account} stake amount ${amount}, final balance ${total}`)
 
     if (stakeService.emit) {
-      stakeService.emit('updated', stake.toJSON())
+      stakeService.emit('updated', stake!.toJSON())
     }
   },
 
   async Unstaked (event: EventData, { stakeService }: StorageServices): Promise<void> {
     const { user: account, total, token, amount } = event.returnValues
 
-    const stakeData = {
-      total,
-      token,
-      account
-    }
-    await StakeModel.upsert(stakeData)
-    const stake = await StakeModel.findOne({ where: { token } })
-
-    if (!stake) {
-      throw new Error(`Stake for token ${stakeData.token} was not created`)
-    }
+    const stake = await StakeModel.findOne({ where: { token, account } })
 
-    logger.info(`Account ${stake.account} unstack amount ${amount}, final balance ${stake.total}`)
+    stake!.total = total
+    await stake!.save()
+    logger.info(`Account ${account} stake amount ${amount}, final balance ${total}`)
 
     if (stakeService.emit) {
-      stakeService.emit('updated', stake.toJSON())
+      stakeService.emit('updated', stake!.toJSON())
     }
   }
 }
@@ -59,10 +43,22 @@ function isValidEvent (value: string): value is keyof typeof handlers {
 
 const handler: Handler<StorageServices> = {
   events: ['Staked', 'Unstaked'],
-  process (event: EventData, services: StorageServices): Promise<void> {
+  async process (event: EventData, services: StorageServices): Promise<void> {
     if (!isValidEvent(event.event)) {
       return Promise.reject(new Error(`Unknown event ${event.event}`))
     }
+    const { user: account, token } = event.returnValues
+    const stake = await StakeModel.findOne({ where: { account, token } })
+
+    // Create stake row if not exist
+    if (!stake) {
+      const stakeFromDb = await StakeModel.create({ account, token, total: '0' })
+      logger.debug('Stake created: ', stakeFromDb.toJSON())
+
+      if (services.stakeService.emit) {
+        services.stakeService.emit('created', stakeFromDb.toJSON())
+      }
+    }
 
     return handlers[event.event](event, services)
   }

src/services/storage/storage.processor.ts

@@ -2,11 +2,12 @@ import { EventData } from 'web3-eth-contract'
 
 import offer from './handlers/offer'
 import request from './handlers/agreement'
+import stake from './handlers/stake'
 import { Handler } from '../../definitions'
 import { Eth } from 'web3-eth'
 import { StorageServices } from './index'
 
-const HANDLERS: Handler<StorageServices>[] = [offer, request]
+const HANDLERS: Handler<StorageServices>[] = [offer, request, stake]
 
 export default function (services: StorageServices, eth: Eth) {
   return async (event: EventData): Promise<void> => {

test/services/storage/processor.spec.ts

@@ -11,12 +11,13 @@ import { Substitute, SubstituteOf } from '@fluffy-spoon/substitute'
 import { Sequelize } from 'sequelize-typescript'
 
 import eventProcessor from '../../../src/services/storage/storage.processor'
-import { AgreementService, OfferService, StorageServices } from '../../../src/services/storage'
+import { AgreementService, OfferService, StakeService, StorageServices } from '../../../src/services/storage'
 import { sequelizeFactory } from '../../../src/sequelize'
 import Offer from '../../../src/services/storage/models/offer.model'
 import { blockMock, eventMock } from '../../utils'
 import { EventError } from '../../../src/errors'
 import BillingPlan from '../../../src/services/storage/models/billing-plan.model'
+import StakeModel from '../../../src/services/storage/models/stake.model'
 import Agreement from '../../../src/services/storage/models/agreement.model'
 import { decodeByteArray, wrapEvent } from '../../../src/utils'
 import { getBlockDate } from '../../../src/blockchain/utils'
@@ -398,4 +399,86 @@ describe('Storage services: Events Processor', () => {
       })
     })
   })
+  describe('Staking events', () => {
+    const token = 'SomeTokenAddress'
+    const account = provider
+    let processor: (event: EventData) => Promise<void>
+    let stakeService: StakeService
+    let stakeServiceEmitSpy: sinon.SinonSpy
+
+    before(() => {
+      stakeService = new StakeService({ Model: StakeModel })
+      processor = eventProcessor({ stakeService } as StorageServices, eth)
+      stakeServiceEmitSpy = sinon.spy()
+      stakeService.emit = stakeServiceEmitSpy
+    })
+    beforeEach(async () => {
+      await sequelize.sync({ force: true })
+      stakeServiceEmitSpy.resetHistory()
+    })
+
+    it('should create new Stake if not existed', async () => {
+      const total = 1000
+      const event = eventMock({
+        event: 'Staked',
+        returnValues: { user: account, total, token, amount: 1000 }
+      })
+      await processor(event)
+      const createdStake = await StakeModel.findOne({ where: { token, account } })
+
+      expect(createdStake).to.be.instanceOf(StakeModel)
+      expect(createdStake?.account).to.be.eql(account)
+      expect(createdStake?.token).to.be.eql(token)
+      expect(stakeServiceEmitSpy).to.have.been.calledWith('created')
+    })
+    it('should not create if existed', async () => {
+      const total = 1000
+      const event = eventMock({
+        event: 'Staked',
+        returnValues: { user: account, total, token, amount: 1000 }
+      })
+      await StakeModel.create({ account, token, total: '0' })
+      await processor(event)
+
+      expect(stakeServiceEmitSpy).to.have.not.been.calledWith('created')
+    })
+    describe('Staked', () => {
+      it('should update total', async () => {
+        const total = 1000
+        const event = eventMock({
+          event: 'Staked',
+          returnValues: {
+            total,
+            user: account,
+            token
+          }
+        })
+
+        await processor(event)
+        const updatedStake = await StakeModel.findOne({ where: { token, account } })
+
+        expect(updatedStake?.total).to.be.eql(new BigNumber(event.returnValues.total))
+        expect(stakeServiceEmitSpy).to.have.been.calledWith('updated', updatedStake!.toJSON())
+      })
+    })
+    describe('Unstaked', () => {
+      it('should update total', async () => {
+        const total = 1000
+        const event = eventMock({
+          event: 'Unstaked',
+          returnValues: {
+            total,
+            user: account,
+            token
+          }
+        })
+
+        await processor(event)
+        const updatedStake = await StakeModel.findOne({ where: { token, account } })
+
+        expect(stakeServiceEmitSpy).to.have.been.calledWith('updated', updatedStake!.toJSON())
+        expect(updatedStake?.total).to.be.eql(new BigNumber(event.returnValues.total))
+      })
+    })
+  })
 })