refactor notifier tests

Author: e11sy

workers/notifier/tests/worker.test.ts

@@ -17,17 +17,14 @@ const rule = {
     telegram: {
       isEnabled: true,
       endpoint: 'tgEndpoint',
-      minPeriod: 0.5,
     },
     slack: {
       isEnabled: true,
       endpoint: 'slackEndpoint',
-      minPeriod: 0.5,
     },
     email: {
       isEnabled: false,
       endpoint: 'emailEndpoint',
-      minPeriod: 0.5,
     },
   },
 } as any;
@@ -200,200 +197,162 @@ describe('NotifierWorker', () => {
   });
 
   describe('handling', () => {
-    it('should correctly handle first message', async () => {
+    it('should not send task to sender workers if event is not new and repetitions today not equal to threshold', async () => {
       const worker = new NotifierWorker();
-
+      
       await worker.start();
 
-      worker.sendToSenderWorker = jest.fn();
+      const message = { ...messageMock };
+      const event = { ...message.event };
+      event.isNew = false;
 
-      worker.buffer.push = jest.fn();
-      worker.buffer.setTimer = jest.fn();
+      worker.redis.getEventRepetitionsFromDigest = jest.fn(async (_projectId, _groupHash) => {
+        return Promise<1>;
+      });
 
-      const message = { ...messageMock };
-      const channels = ['telegram', 'slack'];
-      const channelKeyPart = [message.projectId, rule._id];
-      const events = [ {
-        key: message.event.groupHash,
-        count: 1,
-      } ];
+      worker.redis.getProjectNotificationThreshold = jest.fn(async (_projectId) => {
+        return Promise<10>;
+      });
 
-      await worker.handle(message);
+      worker.sendToSenderWorker = jest.fn();
+
+      worker.handle(message);
 
-      expect(worker.buffer.setTimer).toBeCalledTimes(2);
-      expect(worker.buffer.push).not.toBeCalled();
-
-      channels.forEach((channel, i) => {
-        expect(worker.buffer.setTimer).toHaveBeenNthCalledWith(
-          i + 1,
-          [...channelKeyPart, channel],
-          rule.channels[channel].minPeriod * 1000,
-          worker.sendEvents
-        );
-        expect(worker.sendToSenderWorker).toHaveBeenNthCalledWith(
-          i + 1,
-          [...channelKeyPart, channels[i]],
-          events
-        );
+      /**
+       * Check that we haven't sent any tasks to sender worker
+       * because event repetitions today are less than threshold
+       */
+      expect(worker.sendToSenderWorker).not.toBeCalled();
+
+      worker.redis.getEventRepetitionsFromDigest = jest.fn(async (_projectId, _groupHash) => {
+        return Promise<100>;
       });
 
+      worker.handle(message);
+
+      /**
+       * Check that we haven't sent any tasks to sender worker
+       * because event repetitions today are more than threshold
+       */
+      expect(worker.sendToSenderWorker).not.toBeCalled();
+
       await worker.finish();
     });
 
-    it('should correctly handle messages after first one', async () => {
+    it('should send task to sender workers if event is new', async () => {
       const worker = new NotifierWorker();
 
       await worker.start();
 
+      const message = { ...messageMock };
+      const event = { ...message.event };
+
+      event.isNew = true;
+
       worker.sendToSenderWorker = jest.fn();
 
-      jest.useFakeTimers();
+      worker.handle(message);
 
-      const realGetTimer = worker.buffer.getTimer;
-      const realSetTimer = worker.buffer.setTimer;
+      expect(worker.sendToSenderWorker).toBeCalled();
 
-      worker.buffer.getTimer = jest.fn((...args) => realGetTimer.apply(worker.buffer, args));
-      worker.buffer.setTimer = jest.fn((...args) => realSetTimer.apply(worker.buffer, args));
-      worker.buffer.push = jest.fn();
+      await worker.finish();
+    });
 
-      const message = { ...messageMock };
-      const channels = ['telegram', 'slack'];
-      const channelKeyPart = [message.projectId, rule._id];
+    it('should send task to sender workers if event repetitions today equal to threshold', async () => {
+      const worker = new NotifierWorker();
 
-      await worker.handle(message);
-      await worker.handle(message);
+      await worker.start();
+
+      const message = { ...messageMock };
+      const event = { ...message.event };
+      event.isNew = false;
 
-      expect(worker.buffer.getTimer).toBeCalledTimes(4);
-      expect(worker.buffer.push).toBeCalledTimes(2);
-      expect(worker.sendToSenderWorker).toBeCalledTimes(2);
+      worker.redis.getEventRepetitionsFromDigest = jest.fn(async (_projectId, _groupHash) => {
+        return Promise<10>;
+      });
 
-      channels.forEach((channel, i) => {
-        expect(worker.buffer.push).toHaveBeenNthCalledWith(
-          i + 1,
-          [...channelKeyPart, channel, messageMock.event.groupHash]
-        );
+      worker.redis.getProjectNotificationThreshold = jest.fn(async (_projectId) => {
+        return Promise<10>;
       });
 
-      jest.useRealTimers();
+      worker.sendToSenderWorker = jest.fn();
+
+      worker.handle(message);
+
+      expect(worker.sendToSenderWorker).toBeCalled();
 
       await worker.finish();
     });
 
-    it('should send events after timeout', async () => {
+    it('should not call events database for threshold calculation if threshold set in redis', async () => {
       const worker = new NotifierWorker();
 
       await worker.start();
 
-      worker.sendToSenderWorker = jest.fn();
-
-      const realSendEvents = worker.sendEvents;
-
-      worker.sendEvents = jest.fn((...args) => realSendEvents.apply(worker, args));
+      /**
+       * Mock of the function that returns 
+       */
+      worker.redis.getEventRepetitionsFromDigest = jest.fn(async (_projectId, _groupHash) => {
+        return Promise<1>;
+      });
 
-      const realFlush = worker.buffer.flush;
+      worker.redis.getProjectNotificationThreshold(async (_projectId) => {
+        return Promise<1>;
+      })
 
-      worker.buffer.flush = jest.fn((...args) => realFlush.apply(worker.buffer, args));
+      worker.eventsDb.getConnection = jest.fn();
 
       const message = { ...messageMock };
-      const channels = ['telegram', 'slack'];
-      const channelKeyPart = [message.projectId, rule._id];
 
       await worker.handle(message);
-      await worker.handle(message);
-
-      await new Promise((resolve) => setTimeout(() => {
-        expect(worker.sendEvents).toBeCalledTimes(2);
-        expect(worker.buffer.flush).toBeCalledTimes(2);
 
-        channels.forEach((channel, i) => {
-          expect(worker.buffer.flush).toHaveBeenNthCalledWith(
-            i + 1,
-            [...channelKeyPart, channel]
-          );
-          expect(worker.sendEvents).toHaveBeenNthCalledWith(
-            i + 1,
-            [...channelKeyPart, channel]
-          );
-        });
-
-        resolve();
-      }, 1000));
+      /**
+       * It should not be called beacuse event repetitions got from redis
+       */
+      expect(worker.eventsDb.getConnection).not.toBeCalled;
 
       await worker.finish();
     });
 
-    it('should do nothing if project doesn\'t exist', async () => {
+    it('should calculate notification threshold using events db if redis has no threshold', async () => {
       const worker = new NotifierWorker();
 
       await worker.start();
 
-      worker.addEventsToChannels = jest.fn();
-
-      const message = { ...messageMock };
-
-      const oldMock = dbQueryMock;
+      worker.redis.getProjectNotificationThreshold = jest.fn(async (_projectId, _groupHash) => {
+        return Promise<null>;
+      });
 
-      dbQueryMock = jest.fn(() => null);
+      worker.eventsDb.getConnection = jest.fn();
+      worker.redis.setProjectNotificationTreshold = jest.fn();
+      
+      /**
+       * Check that we connected to the events database to calculate the threshold
+       */
+      expect(worker.eventsDb.getConnection).toBeCalled();
 
-      await worker.handle(message);
+      /**
+       * Check that we stored calculated threshold in redis
+       */
+      expect(worker.redis.setProjectNotificationTreshold).toBeCalled();
 
-      expect(worker.addEventsToChannels).not.toBeCalled();
+      await worker.finish();
+    })
 
-      dbQueryMock = oldMock;
+    it('should always add event to redis digest', async () => {
+      const worker = new NotifierWorker();
 
-      await worker.finish();
-    });
-  });
+      await worker.start();
 
-  it('should send task to sender workers', async () => {
-    const worker = new NotifierWorker();
+      const message = { ...messageMock };
 
-    await worker.start();
+      worker.redis.addEventToDigest = jest.fn();
 
-    await worker.start();
+      worker.handle(message);
 
-    worker.addTask = jest.fn();
-
-    const message = { ...messageMock };
-
-    await worker.handle(message);
-
-    await waitForExpect(() => {
-      expect(worker.addTask).toHaveBeenNthCalledWith(
-        1,
-        `sender/telegram`,
-        {
-          type: 'event',
-          payload: {
-            projectId: message.projectId,
-            ruleId: rule._id,
-            events: [ {
-              key: message.event.groupHash,
-              count: 1,
-            } ],
-          },
-        }
-      );
-    }, 2000);
-
-    await waitForExpect(() => {
-      expect(worker.addTask).toHaveBeenNthCalledWith(
-        2,
-        `sender/slack`,
-        {
-          type: 'event',
-          payload: {
-            projectId: message.projectId,
-            ruleId: rule._id,
-            events: [ {
-              key: message.event.groupHash,
-              count: 1,
-            } ],
-          },
-        }
-      );
-    }, 2000);
+      expect(worker.redis.addEventToDigest).toBeCalled();
 
-    await worker.finish();
+      await worker.finish();
+    });
   });
 });