fixed some test, added tests for diff

Author: slaveeks

workers/grouper/src/data-filter.ts

@@ -1,4 +1,4 @@
-import { EventAddons, EventDataAccepted } from '@hawk.so/types';
+import type { EventAddons, EventDataAccepted } from '@hawk.so/types';
 import { unsafeFields } from '../../../lib/utils/unsafeFields';
 
 /**

workers/grouper/src/index.ts

@@ -6,8 +6,8 @@ import * as utils from '../../../lib/utils';
 import { Worker } from '../../../lib/worker';
 import * as WorkerNames from '../../../lib/workerNames';
 import * as pkg from '../package.json';
-import { GroupWorkerTask, RepetitionDelta } from '../types/group-worker-task';
-import { EventAddons, EventDataAccepted, GroupedEventDBScheme, RepetitionDBScheme } from '@hawk.so/types';
+import type { GroupWorkerTask, RepetitionDelta } from '../types/group-worker-task';
+import type { EventAddons, EventDataAccepted, GroupedEventDBScheme, RepetitionDBScheme } from '@hawk.so/types';
 import { DatabaseReadWriteError, DiffCalculationError, ValidationError } from '../../../lib/workerErrors';
 import { decodeUnsafeFields, encodeUnsafeFields } from '../../../lib/utils/unsafeFields';
 import HawkCatcher from '@hawk.so/nodejs';
@@ -23,21 +23,6 @@ import TimeMs from '../../../lib/utils/time';
  */
 const DB_DUPLICATE_KEY_ERROR = '11000';
 
-/**
- * @todo encodeUnsafeFields/decodeUnsafeFields should process both "payload" and "delta" fields
- * @todo cover repetition save with tests. Test various cases:
- * - original event has no backtrace
- * - original event has backtrace
- * - repetition has no backtrace
- * - repetition has backtrace
- * - backtrace is different
- * - original event has no context.somefield
- * - original event has context.somefield
- * - repetition has no context.somefield
- * - repetition has context.somefield
- * (etc)
- */
-
 /**
  * Worker for handling Javascript events
  */
@@ -212,7 +197,7 @@ export default class GrouperWorker extends Worker {
       const newRepetition = {
         groupHash: uniqueEventHash,
         delta: JSON.stringify(delta),
-        timestamp: task.event.timestamp
+        timestamp: task.event.timestamp,
       } as RepetitionDBScheme;
 
       repetitionId = await this.saveRepetition(task.projectId, newRepetition);
@@ -510,7 +495,7 @@ export default class GrouperWorker extends Worker {
    * @returns {string} cache key for event
    */
   private async getEventCacheKey(projectId: string, groupHash: string): Promise<string> {
-    return `${projectId}:${JSON.stringify({ groupHash: groupHash })}`;
+    return `${projectId}:${JSON.stringify({ groupHash })}`;
   }
 
   /**

workers/grouper/src/redisHelper.ts

@@ -1,5 +1,6 @@
 import HawkCatcher from '@hawk.so/nodejs';
-import { createClient, RedisClientType } from 'redis';
+import type { RedisClientType } from 'redis';
+import { createClient } from 'redis';
 import createLogger from '../../../lib/logger';
 
 /**

workers/grouper/src/utils/repetitionDiff.ts

@@ -1,9 +1,10 @@
-import { EventAddons, EventDataAccepted } from "@hawk.so/types";
-import { diff } from "@n1ru4l/json-patch-plus";
-import { RepetitionDelta } from "../../types/group-worker-task";
+import type { EventAddons, EventDataAccepted } from '@hawk.so/types';
+import { diff } from '@n1ru4l/json-patch-plus';
+import type { RepetitionDelta } from '../../types/group-worker-task';
 
 /**
  * Calculate delta between original event and repetition
+ *
  * @param originalEvent - first event
  * @param repetition - one of remaining events
  * @returns delta

workers/grouper/tests/data-filter.test.ts

@@ -1,5 +1,5 @@
 import '../../../env-test';
-import { EventAddons, EventDataAccepted, Json } from '@hawk.so/types';
+import type { EventAddons, EventDataAccepted, Json } from '@hawk.so/types';
 import DataFilter from '../src/data-filter';
 jest.mock('amqplib');
 

workers/grouper/tests/diff.test.ts

@@ -8,8 +8,8 @@ import { generateEvent } from './mocks/generateEvent';
  * Check that we always can get the whole repetition by applying delta to the original event
  */
 describe('Diff', () => {
-  it('saved delta should allow to get the original repetition using patch', () => {
-    const originalEvent = generateEvent()
+  it('Original event has backtrace, repetition has no backtrace, merged event has no backtrace', () => {
+    const originalEvent = generateEvent();
 
     const repetition = generateEvent({
       backtrace: null,
@@ -26,5 +26,102 @@ describe('Diff', () => {
     });
 
     expect(patched).toEqual(repetition);
-  })
+  });
+  it('Original event has no backtrace, repetition has backtrace, merged event has backtrace', () => {
+    const originalEvent = generateEvent({
+      backtrace: null,
+      context: {
+        testField: 10,
+      },
+    });
+
+    const repetition = generateEvent({
+      backtrace: [
+        {
+          file: 'test.ts',
+          line: 10,
+        },
+      ],
+    });
+
+    const delta = computeDelta(originalEvent, repetition);
+
+    const patched = patch({
+      left: originalEvent,
+      delta,
+    });
+
+    expect(patched).toEqual(repetition);
+  });
+
+  it('Original event and repetition have different backtrace', () => {
+    const originalEvent = generateEvent({
+      backtrace: [
+        {
+          file: 'test.ts',
+          line: 10,
+        },
+      ],
+    });
+
+    const repetition = generateEvent({
+      backtrace: [
+        {
+          file: 'test.ts',
+          line: 11,
+        },
+      ],
+    });
+
+    const delta = computeDelta(originalEvent, repetition);
+
+    const patched = patch({
+      left: originalEvent,
+      delta,
+    });
+
+    expect(patched.backtrace).toEqual(repetition.backtrace);
+  });
+
+  it('Original event has context with "someField" and repetition has no "someField"', () => {
+    const originalEvent = generateEvent({
+      context: {
+        someField: 'someValue',
+      },
+    });
+
+    const repetition = generateEvent({
+      context: {},
+    });
+
+    const delta = computeDelta(originalEvent, repetition);
+
+    const patched = patch({
+      left: originalEvent,
+      delta,
+    });
+
+    expect(patched.context).toEqual(repetition.context);
+  });
+
+  it('Original event has no context with "someField" and repetition has "someField"', () => {
+    const originalEvent = generateEvent({
+      context: {},
+    });
+
+    const repetition = generateEvent({
+      context: {
+        someField: 'someValue',
+      },
+    });
+
+    const delta = computeDelta(originalEvent, repetition);
+
+    const patched = patch({
+      left: originalEvent,
+      delta,
+    });
+
+    expect(patched.context).toEqual(repetition.context);
+  });
 });

workers/grouper/tests/index.test.ts

@@ -1,11 +1,14 @@
 import '../../../env-test';
 import GrouperWorker from '../src';
-import { GroupWorkerTask } from '../types/group-worker-task';
-import { createClient, RedisClientType } from 'redis';
-import { Collection, MongoClient } from 'mongodb';
-import { EventAddons, EventDataAccepted } from '@hawk.so/types';
+import type { GroupWorkerTask, RepetitionDelta } from '../types/group-worker-task';
+import type { RedisClientType } from 'redis';
+import { createClient } from 'redis';
+import type { Collection } from 'mongodb';
+import { MongoClient } from 'mongodb';
+import type { EventAddons, EventDataAccepted } from '@hawk.so/types';
 import { MS_IN_SEC } from '../../../lib/utils/consts';
 import * as mongodb from 'mongodb';
+import { patch } from '@n1ru4l/json-patch-plus';
 
 jest.mock('amqplib');
 
@@ -374,7 +377,7 @@ describe('GrouperWorker', () => {
       }).toArray()).length).toBe(2);
     });
 
-    test('Should stringify payload`s addons and context fields', async () => {
+    test('Should stringify delta', async () => {
       const generatedTask = generateTask();
 
       await worker.handle(generateTask());
@@ -389,35 +392,39 @@ describe('GrouperWorker', () => {
 
       const savedRepetition = await repetitionsCollection.findOne({});
 
-      expect(typeof savedRepetition.payload.addons).toBe('string');
-      expect(typeof savedRepetition.payload.context).toBe('string');
+      expect(typeof savedRepetition.delta).toBe('string');
     });
 
     test('Should correctly calculate diff after encoding original event when they are the same', async () => {
-      await worker.handle(generateTask());
-      await worker.handle(generateTask());
+      await worker.handle(generateTask({ user: { id: '123' } }));
+      await worker.handle(generateTask({ user: { id: '123' } }));
 
       const savedRepetition = await repetitionsCollection.findOne({});
-      const savedPayload = savedRepetition.payload as EventDataAccepted<EventAddons>;
 
-      expect(savedPayload.title).toBe(undefined);
-      expect(savedPayload.type).toBe(undefined);
-      expect(savedPayload.backtrace).toBe(undefined);
-      expect(savedPayload.context).toBe(undefined);
-      expect(savedPayload.addons).toBe(undefined);
-      expect(savedPayload.release).toBe(undefined);
-      expect(savedPayload.user).toBe(undefined);
-      expect(savedPayload.catcherVersion).toBe(undefined);
+      const savedDelta = savedRepetition.delta as string;
+      const parsedDelta = JSON.parse(savedDelta) as RepetitionDelta;
+
+      console.log('parsedDelta', parsedDelta);
+
+      expect(parsedDelta.type).toBe(undefined);
+      expect(parsedDelta.backtrace).toBe(undefined);
+      expect(parsedDelta.context).toBe(undefined);
+      expect(parsedDelta.addons).toBe(undefined);
+      expect(parsedDelta.release).toBe(undefined);
+      expect(parsedDelta.user).toBe(undefined);
+      expect(parsedDelta.catcherVersion).toBe(undefined);
 
       /**
        * Timestamp always unique, so it should be present in a stored payload diff
        */
-      expect(savedPayload.timestamp).not.toBe(undefined);
-      expect(typeof savedPayload.timestamp).toBe('number');
+      expect(parsedDelta.timestamp).not.toBe(undefined);
+      expect(typeof parsedDelta.timestamp).toBe('object');
     });
 
     test('Should correctly calculate diff after encoding original event when they are different', async () => {
-      await worker.handle(generateTask());
+      const originalGeneratedEvent = generateTask();
+
+      await worker.handle(originalGeneratedEvent);
 
       const generatedTask = generateTask();
 
@@ -436,11 +443,33 @@ describe('GrouperWorker', () => {
         },
       });
 
+      const savedEvent = await eventsCollection.findOne({});
       const savedRepetition = await repetitionsCollection.findOne({});
-      const savedPayload = savedRepetition.payload as EventDataAccepted<EventAddons>;
+      const savedDelta = savedRepetition.delta as string;
+      const parsedDelta = JSON.parse(savedDelta) as RepetitionDelta;
 
-      expect(savedPayload.context).toBe('{"testField":9}');
-      expect(savedPayload.addons).toBe('{"vue":{"props":{"test-test":true}}}');
+      /**
+       * Parse context and addons from string to object
+       */
+      savedEvent.payload.context = JSON.parse(savedEvent.payload.context);
+      savedEvent.payload.addons = JSON.parse(savedEvent.payload.addons);
+
+      expect(typeof parsedDelta.context).toBe('object');
+      expect(typeof parsedDelta.addons).toBe('object');
+
+      const patched = patch({
+        left: savedEvent.payload,
+        delta: parsedDelta,
+      });
+
+      expect(patched.context).toEqual({
+        testField: 9,
+      });
+      expect(patched.addons).toEqual({
+        vue: {
+          props: { 'test-test': true },
+        },
+      });
     });
   });
 

workers/grouper/tests/mocks/generateEvent.ts

@@ -1,12 +1,15 @@
-import { EventAddons, EventDataAccepted } from "@hawk.so/types";
-import { generateRandomId } from "./randomId";
+import type { EventAddons, EventDataAccepted } from '@hawk.so/types';
+import { generateRandomId } from './randomId';
 
 /**
  * Mocked User id used for tests
  */
 const userIdMock = generateRandomId();
 
-
+/**
+ *
+ * @param event
+ */
 export function generateEvent(event: Partial<EventDataAccepted<EventAddons>> = undefined): EventDataAccepted<EventAddons> {
   return {
     title: 'Hawk client catcher test',

workers/grouper/tests/mocks/generateTask.ts

@@ -1,15 +1,15 @@
-import { EventAddons, EventDataAccepted } from "@hawk.so/types";
-import { GroupWorkerTask } from "../../types/group-worker-task";
-import { projectIdMock } from "./projectId";
-import { generateEvent } from "./generateEvent";
+import type { EventAddons, EventDataAccepted } from '@hawk.so/types';
+import type { GroupWorkerTask } from '../../types/group-worker-task';
+import { projectIdMock } from './projectId';
+import { generateEvent } from './generateEvent';
 
 /**
  * Generates task for testing
  *
  * @param event - allows to override some event properties in generated task
  */
 export function generateTask(
-  event: Partial<EventDataAccepted<EventAddons>> = undefined,
+  event: Partial<EventDataAccepted<EventAddons>> = undefined
 ): GroupWorkerTask {
   return {
     projectId: projectIdMock,

workers/grouper/tests/mocks/randomId.ts

@@ -6,4 +6,3 @@ export function generateRandomId(): string {
     .substring(2, 15) + Math.random().toString(36)
     .substring(2, 15);
 }
-