packages/metrics/tests/MetricsApi.test.ts

   1 import { HTTP_STATUS_CODE, SECOND } from '@proton/shared/lib/constants';
   2 import { wait } from '@proton/shared/lib/helpers/promise';
   3
   4 import { METRICS_DEFAULT_RETRY_SECONDS, METRICS_MAX_ATTEMPTS, METRICS_REQUEST_TIMEOUT_SECONDS } from '../constants';
   5 import MetricsApi from '../lib/MetricsApi';
   6
   7 jest.mock('@proton/shared/lib/helpers/promise');
   8
   9 function getHeader(headers: HeadersInit | undefined, headerName: string) {
  10     // @ts-ignore
  11     return headers[headerName];
  12 }
  13
  14 describe('MetricsApi', () => {
  15     beforeEach(() => {
  16         fetchMock.resetMocks();
  17     });
  18
  19     describe('constructor', () => {
  20         describe('auth headers', () => {
  21             it('sets auth headers when uid is defined', async () => {
  22                 const uid = 'uid';
  23                 const metricsApi = new MetricsApi({ uid });
  24
  25                 await metricsApi.fetch('/route');
  26                 const content = fetchMock.mock.lastCall?.[1];
  27
  28                 expect(fetchMock).toHaveBeenCalledTimes(1);
  29                 expect(getHeader(content?.headers, 'x-pm-uid')).toBe(uid);
  30             });
  31
  32             it('does not set auth headers when uid is not defined', async () => {
  33                 const metricsApi = new MetricsApi();
  34
  35                 await metricsApi.fetch('/route');
  36                 const content = fetchMock.mock.lastCall?.[1];
  37
  38                 expect(fetchMock).toHaveBeenCalledTimes(1);
  39                 expect(getHeader(content?.headers, 'x-pm-uid')).toBe(undefined);
  40             });
  41         });
  42
  43         describe('app version headers', () => {
  44             it('sets app version headers when clientID and appVersion are defined', async () => {
  45                 const clientID = 'clientID';
  46                 const appVersion = 'appVersion';
  47                 const metricsApi = new MetricsApi({ clientID, appVersion });
  48
  49                 await metricsApi.fetch('/route');
  50                 const content = fetchMock.mock.lastCall?.[1];
  51
  52                 expect(fetchMock).toHaveBeenCalledTimes(1);
  53                 expect(getHeader(content?.headers, 'x-pm-appversion')).toBe(`${clientID}@${appVersion}-dev`);
  54             });
  55
  56             it('does not set app version headers when clientID is not defined', async () => {
  57                 const appVersion = 'appVersion';
  58                 const metricsApi = new MetricsApi({ appVersion });
  59
  60                 await metricsApi.fetch('/route');
  61                 const content = fetchMock.mock.lastCall?.[1];
  62
  63                 expect(fetchMock).toHaveBeenCalledTimes(1);
  64                 expect(getHeader(content?.headers, 'x-pm-appversion')).toBe(undefined);
  65             });
  66
  67             it('does not set app version headers when appVersion is not defined', async () => {
  68                 const clientID = 'clientID';
  69                 const metricsApi = new MetricsApi({ clientID });
  70
  71                 await metricsApi.fetch('/route');
  72                 const content = fetchMock.mock.lastCall?.[1];
  73
  74                 expect(fetchMock).toHaveBeenCalledTimes(1);
  75                 expect(getHeader(content?.headers, 'x-pm-appversion')).toBe(undefined);
  76             });
  77         });
  78     });
  79
  80     describe('setAuthHeaders', () => {
  81         it('sets auth headers when uid is defined', async () => {
  82             const uid = 'uid';
  83             const metricsApi = new MetricsApi();
  84
  85             metricsApi.setAuthHeaders(uid);
  86
  87             await metricsApi.fetch('/route');
  88             const content = fetchMock.mock.lastCall?.[1];
  89
  90             expect(fetchMock).toHaveBeenCalledTimes(1);
  91             expect(getHeader(content?.headers, 'x-pm-uid')).toBe(uid);
  92         });
  93
  94         it('does not set auth headers when uid is an empty string', async () => {
  95             const uid = '';
  96             const metricsApi = new MetricsApi();
  97
  98             metricsApi.setAuthHeaders(uid);
  99
 100             await metricsApi.fetch('/route');
 101             const content = fetchMock.mock.lastCall?.[1];
 102
 103             expect(fetchMock).toHaveBeenCalledTimes(1);
 104             expect(getHeader(content?.headers, 'x-pm-uid')).toBe(undefined);
 105         });
 106
 107         it('sets auth headers with Authorization when uid and access token are defined', async () => {
 108             const uid = 'uid';
 109             const accessToken = 'accessToken';
 110             const metricsApi = new MetricsApi();
 111
 112             metricsApi.setAuthHeaders(uid, accessToken);
 113
 114             await metricsApi.fetch('/route');
 115             const content = fetchMock.mock.lastCall?.[1];
 116
 117             expect(fetchMock).toHaveBeenCalledTimes(1);
 118             expect(getHeader(content?.headers, 'x-pm-uid')).toBe(uid);
 119             expect(getHeader(content?.headers, 'Authorization')).toBe(`Bearer ${accessToken}`);
 120         });
 121     });
 122
 123     describe('setVersionHeaders', () => {
 124         it('sets app version headers when clientID and appVersion are defined', async () => {
 125             const clientID = 'clientID';
 126             const appVersion = 'appVersion';
 127             const metricsApi = new MetricsApi();
 128
 129             metricsApi.setVersionHeaders(clientID, appVersion);
 130
 131             await metricsApi.fetch('/route');
 132             const content = fetchMock.mock.lastCall?.[1];
 133
 134             expect(fetchMock).toHaveBeenCalledTimes(1);
 135             expect(getHeader(content?.headers, 'x-pm-appversion')).toBe(`${clientID}@${appVersion}-dev`);
 136         });
 137
 138         it('does not set app version headers when clientID is an empty string', async () => {
 139             const clientID = '';
 140             const appVersion = 'appVersion';
 141             const metricsApi = new MetricsApi();
 142
 143             metricsApi.setVersionHeaders(clientID, appVersion);
 144
 145             await metricsApi.fetch('/route');
 146             const content = fetchMock.mock.lastCall?.[1];
 147
 148             expect(fetchMock).toHaveBeenCalledTimes(1);
 149             expect(getHeader(content?.headers, 'x-pm-appversion')).toBe(undefined);
 150         });
 151
 152         it('does not set app version headers when appVersion is an empty string', async () => {
 153             const clientID = 'clientID';
 154             const appVersion = '';
 155             const metricsApi = new MetricsApi();
 156
 157             metricsApi.setVersionHeaders(clientID, appVersion);
 158
 159             await metricsApi.fetch('/route');
 160             const content = fetchMock.mock.lastCall?.[1];
 161
 162             expect(fetchMock).toHaveBeenCalledTimes(1);
 163             expect(getHeader(content?.headers, 'x-pm-appversion')).toBe(undefined);
 164         });
 165     });
 166
 167     describe('fetch', () => {
 168         it('throws if fetch rejects', async () => {
 169             fetchMock.mockResponseOnce(() => Promise.reject(new Error('asd')));
 170             const metricsApi = new MetricsApi();
 171
 172             await expect(async () => {
 173                 await metricsApi.fetch('/route');
 174             }).rejects.toThrow();
 175         });
 176
 177         it('sets content-type header to application/json', async () => {
 178             const metricsApi = new MetricsApi();
 179
 180             await metricsApi.fetch('/route');
 181             const content = fetchMock.mock.lastCall?.[1];
 182
 183             expect(fetchMock).toHaveBeenCalledTimes(1);
 184             expect(getHeader(content?.headers, 'content-type')).toBe('application/json');
 185         });
 186
 187         it('sets priority header to u=6', async () => {
 188             const metricsApi = new MetricsApi();
 189
 190             await metricsApi.fetch('/route');
 191             const content = fetchMock.mock.lastCall?.[1];
 192
 193             expect(fetchMock).toHaveBeenCalledTimes(1);
 194             expect(getHeader(content?.headers, 'priority')).toBe('u=6');
 195         });
 196
 197         it('forwards request info', async () => {
 198             const route = '/route';
 199             const metricsApi = new MetricsApi();
 200
 201             await metricsApi.fetch(route);
 202             const url = fetchMock.mock.lastCall?.[0];
 203
 204             expect(fetchMock).toHaveBeenCalledTimes(1);
 205             expect(url).toBe(route);
 206         });
 207
 208         it('forwards request init params', async () => {
 209             const method = 'post';
 210             const body = 'body';
 211             const metricsApi = new MetricsApi();
 212
 213             await metricsApi.fetch('/route', {
 214                 method,
 215                 body,
 216                 headers: {
 217                     foo: 'bar',
 218                 },
 219             });
 220             const content = fetchMock.mock.lastCall?.[1];
 221
 222             expect(fetchMock).toHaveBeenCalledTimes(1);
 223             expect(content?.method).toBe(method);
 224             expect(content?.body).toBe(body);
 225             expect(getHeader(content?.headers, 'foo')).toBe('bar');
 226         });
 227
 228         describe('retry', () => {
 229             const getRetryImplementation = (url: string, retrySeconds?: string) => async (req: Request) => {
 230                 if (req.url === url) {
 231                     return retrySeconds === undefined
 232                         ? { status: HTTP_STATUS_CODE.TOO_MANY_REQUESTS }
 233                         : {
 234                               status: HTTP_STATUS_CODE.TOO_MANY_REQUESTS,
 235                               headers: {
 236                                   'retry-after': retrySeconds,
 237                               },
 238                           };
 239                 }
 240
 241                 return '';
 242             };
 243
 244             it('retries request if response contains retry-after header', async () => {
 245                 fetchMock.mockResponseOnce(getRetryImplementation('/retry', '1'));
 246                 const metricsApi = new MetricsApi();
 247
 248                 await metricsApi.fetch('/retry');
 249
 250                 expect(fetchMock).toHaveBeenCalledTimes(2);
 251             });
 252
 253             it('respects the time the retry header contains', async () => {
 254                 fetchMock.mockResponseOnce(getRetryImplementation('/retry', '1'));
 255                 fetchMock.mockResponseOnce(getRetryImplementation('/retry', '2'));
 256                 fetchMock.mockResponseOnce(getRetryImplementation('/retry', '3'));
 257                 const metricsApi = new MetricsApi();
 258
 259                 await metricsApi.fetch('/retry');
 260
 261                 expect(wait).toHaveBeenNthCalledWith(1, 1 * SECOND);
 262                 expect(wait).toHaveBeenNthCalledWith(2, 2 * SECOND);
 263                 expect(wait).toHaveBeenNthCalledWith(3, 3 * SECOND);
 264             });
 265
 266             it(`throws error if maximum retry limit is hit`, async () => {
 267                 fetchMock.mockResponse(getRetryImplementation('/retry', '1'));
 268                 const metricsApi = new MetricsApi();
 269
 270                 await expect(metricsApi.fetch('/retry')).rejects.toThrow('Too many requests');
 271
 272                 expect(fetchMock).toHaveBeenCalledTimes(METRICS_MAX_ATTEMPTS);
 273             });
 274
 275             it(`uses default retry of ${METRICS_DEFAULT_RETRY_SECONDS} if retry is 0`, async () => {
 276                 fetchMock.mockResponseOnce(getRetryImplementation('/retry', '0'));
 277                 const metricsApi = new MetricsApi();
 278
 279                 await metricsApi.fetch('/retry');
 280
 281                 expect(wait).toHaveBeenCalledWith(METRICS_DEFAULT_RETRY_SECONDS * SECOND);
 282             });
 283
 284             it(`uses default retry of ${METRICS_DEFAULT_RETRY_SECONDS} if retry is NaN`, async () => {
 285                 fetchMock.mockResponseOnce(getRetryImplementation('/retry', 'hello'));
 286                 const metricsApi = new MetricsApi();
 287
 288                 await metricsApi.fetch('/retry');
 289
 290                 expect(wait).toHaveBeenCalledWith(METRICS_DEFAULT_RETRY_SECONDS * SECOND);
 291             });
 292
 293             it(`uses default retry of ${METRICS_DEFAULT_RETRY_SECONDS} if retry is negative`, async () => {
 294                 fetchMock.mockResponseOnce(getRetryImplementation('/retry', '-1'));
 295                 const metricsApi = new MetricsApi();
 296
 297                 await metricsApi.fetch('/retry');
 298
 299                 expect(wait).toHaveBeenCalledWith(METRICS_DEFAULT_RETRY_SECONDS * SECOND);
 300             });
 301
 302             it(`uses default retry of ${METRICS_DEFAULT_RETRY_SECONDS} if retry is not defined`, async () => {
 303                 fetchMock.mockResponseOnce(getRetryImplementation('/retry'));
 304                 const metricsApi = new MetricsApi();
 305
 306                 await metricsApi.fetch('/retry');
 307
 308                 expect(wait).toHaveBeenCalledWith(METRICS_DEFAULT_RETRY_SECONDS * SECOND);
 309             });
 310
 311             it('floors non integer values', async () => {
 312                 fetchMock.mockResponseOnce(getRetryImplementation('/retry', '2.5'));
 313                 const metricsApi = new MetricsApi();
 314
 315                 await metricsApi.fetch('/retry');
 316
 317                 expect(wait).toHaveBeenCalledWith(2 * SECOND);
 318             });
 319         });
 320
 321         describe('timeout', () => {
 322             beforeAll(() => {
 323                 jest.useFakeTimers();
 324             });
 325
 326             beforeEach(() => {
 327                 jest.clearAllTimers();
 328             });
 329
 330             afterAll(() => {
 331                 jest.useRealTimers();
 332             });
 333
 334             const timeoutRequestMock = () =>
 335                 new Promise<{ body: string }>((resolve) => {
 336                     setTimeout(() => resolve({ body: 'ok' }), METRICS_REQUEST_TIMEOUT_SECONDS * SECOND + 1);
 337                     jest.advanceTimersByTime(METRICS_REQUEST_TIMEOUT_SECONDS * SECOND + 1);
 338                 });
 339
 340             it('retries request if request aborts', async () => {
 341                 fetchMock.mockAbortOnce();
 342                 const metricsApi = new MetricsApi();
 343
 344                 await metricsApi.fetch('/route');
 345
 346                 expect(fetchMock).toHaveBeenCalledTimes(2);
 347             });
 348
 349             it('throws error if request continually aborts', async () => {
 350                 fetchMock.mockAbort();
 351                 const metricsApi = new MetricsApi();
 352
 353                 await expect(metricsApi.fetch('/route')).rejects.toThrow('Too many requests');
 354                 expect(fetchMock).toHaveBeenCalledTimes(METRICS_MAX_ATTEMPTS);
 355             });
 356
 357             it(`retries request if response takes longer than ${METRICS_REQUEST_TIMEOUT_SECONDS} seconds`, async () => {
 358                 fetchMock.mockResponseOnce(timeoutRequestMock);
 359                 const metricsApi = new MetricsApi();
 360
 361                 await metricsApi.fetch('/route');
 362
 363                 expect(fetchMock).toHaveBeenCalledTimes(2);
 364             });
 365
 366             it(`waits ${METRICS_DEFAULT_RETRY_SECONDS} seconds before retrying`, async () => {
 367                 fetchMock.mockResponseOnce(timeoutRequestMock);
 368                 const metricsApi = new MetricsApi();
 369
 370                 await metricsApi.fetch('/route');
 371
 372                 expect(wait).toHaveBeenNthCalledWith(1, METRICS_DEFAULT_RETRY_SECONDS * SECOND);
 373             });
 374
 375             it(`throws error if request continually timesout`, async () => {
 376                 fetchMock.mockResponse(timeoutRequestMock);
 377                 const metricsApi = new MetricsApi();
 378
 379                 await expect(metricsApi.fetch('/route')).rejects.toThrow('Too many requests');
 380
 381                 expect(fetchMock).toHaveBeenCalledTimes(METRICS_MAX_ATTEMPTS);
 382             });
 383         });
 384     });
 385 });