applications/drive/src/app/store/_events/driveEventsMetrics.test.ts

   1 import metrics from '@proton/metrics';
   2 import { EVENT_TYPES } from '@proton/shared/lib/drive/constants';
   3 import type { DriveEventsResult } from '@proton/shared/lib/interfaces/drive/events';
   4
   5 import type { DriveEvent } from '.';
   6 import type { EncryptedLink } from '../_links';
   7 import { VolumeType } from '../_volumes';
   8 import { EventsMetrics, countEventsPerType } from './driveEventsMetrics';
   9
  10 jest.mock('@proton/metrics', () => ({
  11     drive_sync_event_total: {
  12         increment: jest.fn(),
  13     },
  14     drive_sync_event_unecessary_total: {
  15         increment: jest.fn(),
  16     },
  17 }));
  18
  19 describe('EventsMetrics', () => {
  20     let eventsMetrics: EventsMetrics;
  21
  22     beforeEach(() => {
  23         eventsMetrics = new EventsMetrics();
  24         jest.clearAllMocks();
  25     });
  26
  27     test('processed method adds events correctly', () => {
  28         const event: DriveEvent = {
  29             eventType: EVENT_TYPES.CREATE,
  30             encryptedLink: { volumeId: 'vol1', linkId: 'link1' } as EncryptedLink,
  31         };
  32         eventsMetrics.processed('event1', event);
  33
  34         const state = (eventsMetrics as any).state;
  35         expect(state.get('vol1-event1')).toEqual({
  36             create: new Set(['link1']),
  37         });
  38     });
  39
  40     test('batchStart method initializes events correctly', () => {
  41         const driveEvents: DriveEventsResult = {
  42             EventID: 'event1',
  43             Events: [
  44                 { EventType: EVENT_TYPES.CREATE, Link: { LinkID: 'link1' } },
  45                 { EventType: EVENT_TYPES.DELETE, Link: { LinkID: 'link2' } },
  46             ],
  47         } as DriveEventsResult;
  48         eventsMetrics.batchStart('vol1', driveEvents);
  49
  50         const events = (eventsMetrics as any).events;
  51         expect(events.get('vol1-event1')).toEqual({
  52             create: new Set(['link1']),
  53             delete: new Set(['link2']),
  54             update: new Set(),
  55             update_metadata: new Set(),
  56         });
  57     });
  58
  59     test('batchCompleted method processes batch correctly', () => {
  60         const driveEvents: DriveEventsResult = {
  61             EventID: 'event1',
  62             Events: [
  63                 { EventType: EVENT_TYPES.CREATE, Link: { LinkID: 'link1' } },
  64                 { EventType: EVENT_TYPES.DELETE, Link: { LinkID: 'link2' } },
  65             ],
  66         } as DriveEventsResult;
  67         eventsMetrics.batchStart('vol1', driveEvents);
  68         eventsMetrics.processed('event1', {
  69             eventType: EVENT_TYPES.CREATE,
  70             encryptedLink: { volumeId: 'vol1', linkId: 'link1' } as EncryptedLink,
  71         });
  72         eventsMetrics.batchCompleted('vol1', 'event1', VolumeType.main);
  73
  74         expect(metrics.drive_sync_event_unecessary_total.increment).toHaveBeenCalledWith(
  75             { volumeType: VolumeType.main, eventType: 'delete' },
  76             1
  77         );
  78     });
  79 });
  80
  81 describe('countEventsPerType', () => {
  82     beforeEach(() => {
  83         jest.clearAllMocks();
  84     });
  85
  86     test('counts events correctly', () => {
  87         const driveEvents: DriveEventsResult = {
  88             Events: [
  89                 { EventType: EVENT_TYPES.CREATE },
  90                 { EventType: EVENT_TYPES.UPDATE },
  91                 { EventType: EVENT_TYPES.UPDATE },
  92                 { EventType: EVENT_TYPES.DELETE },
  93                 { EventType: EVENT_TYPES.UPDATE_METADATA },
  94             ],
  95         } as DriveEventsResult;
  96
  97         countEventsPerType(VolumeType.main, driveEvents);
  98
  99         expect(metrics.drive_sync_event_total.increment).toHaveBeenCalledTimes(4);
 100         expect(metrics.drive_sync_event_total.increment).toHaveBeenCalledWith(
 101             { volumeType: VolumeType.main, eventType: 'create' },
 102             1
 103         );
 104         expect(metrics.drive_sync_event_total.increment).toHaveBeenCalledWith(
 105             { volumeType: VolumeType.main, eventType: 'update' },
 106             2
 107         );
 108         expect(metrics.drive_sync_event_total.increment).toHaveBeenCalledWith(
 109             { volumeType: VolumeType.main, eventType: 'delete' },
 110             1
 111         );
 112         expect(metrics.drive_sync_event_total.increment).toHaveBeenCalledWith(
 113             { volumeType: VolumeType.main, eventType: 'update_metadata' },
 114             1
 115         );
 116     });
 117
 118     test('handles undefined events', () => {
 119         const driveEvents: DriveEventsResult = {} as DriveEventsResult;
 120         countEventsPerType(VolumeType.main, driveEvents);
 121         expect(metrics.drive_sync_event_total.increment).not.toHaveBeenCalled();
 122     });
 123 });