feat(storage): remove unnecessary logger in switch statement(never …

…rich this place)

Add test's for `MessageEmitted` event

src/services/storage/handlers/offer.ts

@@ -51,7 +51,7 @@ const handler: Handler<StorageServices> = {
         const flag = firstMsg.substring(2, 4)
 
         if (flag === '01') { // PeerId definition
-          offer.peerId = decodeByteArray([firstMsg.substring(4), ...restMsg])
+          offer.peerId = decodeByteArray([`0x${firstMsg.substring(4)}`, ...restMsg])
           logger.info(`PeerId ${offer.peerId} defined (ID: ${offer.address})`)
         } else {
           throw new EventError(`Unknown message flag ${flag}!`, event.event)
@@ -62,7 +62,7 @@ const handler: Handler<StorageServices> = {
         await updatePrices(offer, event.returnValues.period, event.returnValues.price)
         break
       default:
-        throw new EventError('Unknown event', event.event)
+        break
     }
 
     await offer.save()

test/services/storage/storage.spec.ts

@@ -4,6 +4,7 @@ import sinonChai from 'sinon-chai'
 import dirtyChai from 'dirty-chai'
 import sinon from 'sinon'
 import { EventData } from 'web3-eth-contract'
+import { asciiToHex } from 'web3-utils'
 import Eth from 'web3-eth'
 import { SubstituteOf } from '@fluffy-spoon/substitute'
 import { Sequelize } from 'sequelize-typescript'
@@ -13,6 +14,7 @@ import { OfferService, StorageServices } from '../../../src/services/storage'
 import { sequelizeFactory } from '../../../src/sequelize'
 import Offer from '../../../src/services/storage/models/offer.model'
 import { eventMock } from '../../utils'
+import { EventError } from '../../../src/errors'
 
 chai.use(sinonChai)
 chai.use(chaiAsPromised)
@@ -35,12 +37,12 @@ describe('Storage services', function () {
 
       before(() => {
         offerService = new OfferService({ Model: Offer })
-        offerServiceEmitSpy = sinon.spy()
-        offerService.emit = offerServiceEmitSpy
         processor = eventProcessor({ offerService } as StorageServices, eth)
       })
       beforeEach(async () => {
         await sequelize.sync({ force: true })
+        offerServiceEmitSpy = sinon.spy()
+        offerService.emit = offerServiceEmitSpy
       })
 
       it('should create new Offer if not existed', async () => {
@@ -54,22 +56,81 @@ describe('Storage services', function () {
         expect(createdEvent).to.be.instanceOf(Offer)
         expect(offerServiceEmitSpy).to.have.been.calledWithMatch('created')
       })
-      it('should update existing Offer', async () => {
+      it('should update existed Offer', async () => {
+        const event = eventMock({
+          event: 'TotalCapacitySet',
+          returnValues: {
+            capacity: 1000,
+            provider
+          }
+        })
+        const eventFromDb = await Offer.create({ address: event.returnValues.provider })
+        expect(eventFromDb).to.be.instanceOf(Offer)
+
+        await processor(event)
+
+        expect(offerServiceEmitSpy).to.have.been.calledWithMatch('updated')
+      })
+      it('should update capacity on `TotalCapacitySet`', async () => {
         const event = eventMock({
           event: 'TotalCapacitySet',
           returnValues: {
             capacity: 1000,
             provider
           }
         })
+
         await processor(event)
         const updatedEventFromDB = await Offer.findOne({ where: { address: event.returnValues.provider } })
 
         expect(updatedEventFromDB?.totalCapacity).to.be.eql(event.returnValues.capacity)
-        expect(offerServiceEmitSpy).to.have.been.calledWithMatch('updated')
       })
-      // it ('Should update capacity on "TotalCapacitySet" event', () => {})
-      // it ('Should update prices on "BillingPlanSet" event', () => {})
+      it('should not update Offer on `MessageEmitted` with empty message', async () => {
+        const event = eventMock({
+          event: 'MessageEmitted',
+          returnValues: {
+            message: '',
+            provider
+          }
+        })
+
+        await processor(event)
+        const updatedEventFromDB = await Offer.findOne({ where: { address: event.returnValues.provider } })
+
+        expect(updatedEventFromDB?.peerId).to.be.eql(null)
+      })
+      it('should update `peerId` on "MessageEmitted" event', async () => {
+        const testPeerId = 'FakePeerId'
+        const testPeerIdHex = asciiToHex(testPeerId, 32).replace('0x', '')
+        const nodeIdFlag = '01'
+        const message = `0x${nodeIdFlag}${testPeerIdHex}`
+        const event = eventMock({
+          event: 'MessageEmitted',
+          returnValues: {
+            message: [message],
+            provider
+          }
+        })
+
+        await processor(event)
+        const updatedEventFromDB = await Offer.findOne({ where: { address: event.returnValues.provider } })
+
+        expect(updatedEventFromDB?.peerId).to.be.eql(testPeerId)
+      })
+      it('should throw error on unknown message flag of "MessageEmitted" event', async () => {
+        const testPeerId = 'FakePeerId'
+        const testPeerIdHex = asciiToHex(testPeerId, 32).replace('0x', '')
+        const unknownId = '02'
+        const event = eventMock({
+          event: 'MessageEmitted',
+          returnValues: {
+            message: [`0x${unknownId}${testPeerIdHex}`],
+            provider
+          }
+        })
+
+        await expect(processor(event)).to.eventually.be.rejectedWith(EventError, `During processing event MessageEmitted: Unknown message flag ${unknownId}!`)
+      })
     })
   })
 })