feat(offer-events): adjust message parsing of MessageEmitted event

throw error on unknown event and event parsing
resolve PR comments

src/services/storage/handlers/offer.ts

@@ -5,6 +5,7 @@ import { loggingFactory } from '../../../logger'
 import { Handler } from '../../../definitions'
 import { StorageServices } from '../index'
 import { decodeByteArray } from '../../../utils'
+import { EventError } from '../../../errors'
 
 const logger = loggingFactory('storage:handler:offer')
 
@@ -46,28 +47,28 @@ const handler: Handler<StorageServices> = {
           break
         }
 
-        const [firstMsg, ...restMsg] = msg[0].replace('0x', '')
-        const flag = firstMsg.substring(0, 2)
+        const [firstMsg, ...restMsg] = msg
+        const flag = firstMsg.substring(2, 4)
 
         if (flag === '01') { // PeerId definition
-          offer.peerId = decodeByteArray([firstMsg.substring(2), ...restMsg])
+          offer.peerId = decodeByteArray([firstMsg.substring(4), ...restMsg])
           logger.info(`PeerId ${offer.peerId} defined (ID: ${offer.address})`)
         } else {
-          logger.error(`Unknown message flag ${flag}!`)
+          throw new EventError(`Unknown message flag ${flag}!`, event.event)
         }
         break
       }
       case 'BillingPlanSet':
         await updatePrices(offer, event.returnValues.period, event.returnValues.price)
         break
       default:
-        logger.error(`Unknown event ${event.event}`)
+        throw new EventError('Unknown event', event.event)
     }
 
     await offer.save()
 
     // @TODO if we receive an unknown message then update actually doesn't happens, because offer don't changed
-    // Should we emit `update` event then
+    // Should we emit `update` event then???
     if (offerService.emit) offerService.emit(created ? 'created' : 'updated', offer.toJSON())
   }
 }

test/services/storage/storage.spec.ts

@@ -12,26 +12,15 @@ import eventProcessor from '../../../src/services/storage/storage.processor'
 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'
 
 chai.use(sinonChai)
 chai.use(chaiAsPromised)
 chai.use(dirtyChai)
 const expect = chai.expect
 
-const mockEventsFactory = (event: Record<string, unknown> = {}): EventData => Object.assign({
-  returnValues: { provider: 'ProviderAddress' },
-  raw: { data: 'data', topics: [] },
-  event: 'MessageEmitted',
-  signature: 'Sig',
-  logIndex: 2,
-  transactionIndex: 2,
-  transactionHash: 'TestTransactionHASH',
-  blockHash: 'TestBlockHASH',
-  blockNumber: 10,
-  address: 'testADdress'
-}, event) as EventData
-
 describe('Storage services', function () {
+  const provider = 'TestAddress'
   let sequelize: Sequelize
   let eth: SubstituteOf<Eth>
 
@@ -54,28 +43,29 @@ describe('Storage services', function () {
         await sequelize.sync({ force: true })
       })
 
-      it('Should create new Offer if not existed', async () => {
-        const event = mockEventsFactory()
+      it('should create new Offer if not existed', async () => {
+        const event = eventMock({
+          event: 'MessageEmitted',
+          returnValues: { provider }
+        })
         await processor(event)
         const createdEvent = await Offer.findOne({ where: { address: event.returnValues.provider } })
 
         expect(createdEvent).to.be.instanceOf(Offer)
         expect(offerServiceEmitSpy).to.have.been.calledWithMatch('created')
       })
-      it('Should update existing Offer', async () => {
-        const event = mockEventsFactory({
+      it('should update existing Offer', async () => {
+        const event = eventMock({
           event: 'TotalCapacitySet',
           returnValues: {
-            provider: 'TestAddress',
-            totalCapacity: 1000
+            capacity: 1000,
+            provider
           }
         })
-        const eventFromDb = await Offer.create({ address: event.returnValues.provider })
         await processor(event)
         const updatedEventFromDB = await Offer.findOne({ where: { address: event.returnValues.provider } })
 
-        expect(updatedEventFromDB?.updatedAt).to.be.gt(eventFromDb.updatedAt)
-        expect(eventFromDb).to.be.instanceOf(Offer)
+        expect(updatedEventFromDB?.totalCapacity).to.be.eql(event.returnValues.capacity)
         expect(offerServiceEmitSpy).to.have.been.calledWithMatch('updated')
       })
       // it ('Should update capacity on "TotalCapacitySet" event', () => {})