Merge pull request #20243 from mozilla/fxa-12562

feat(auth): migrate metrics/logging/monitoring tests from Mocha to Jest

Author: vbudhram

packages/fxa-auth-server/lib/log.spec.ts

@@ -0,0 +1,154 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+
+import { MetricsRedis, MetricsRedisConfig } from './metricsCache';
+
+// Mock typedi so Container.has() always returns false, preventing DI lookups.
+jest.mock('typedi', () => ({
+  Container: { has: jest.fn().mockReturnValue(false), get: jest.fn() },
+  Token: jest.fn(),
+}));
+
+// Mock RedisShared so the constructor does not create a real ioredis connection.
+// We replace `this.redis` in beforeEach anyway, but this prevents side effects.
+jest.mock('fxa-shared/db/redis', () => {
+  class RedisShared {
+    redis: any = {};
+    constructor() {
+      // no-op
+    }
+  }
+  return { RedisShared, Config: {} };
+});
+
+describe('MetricsRedis', () => {
+  let metricsRedis: MetricsRedis;
+  let redisStub: {
+    exists: jest.Mock;
+    set: jest.Mock;
+    get: jest.Mock;
+    del: jest.Mock;
+  };
+
+  const KEY = `testKey${Date.now()}`;
+  const metricsContext = {
+    deviceId: 'eb3a368713e94801b0f3a67df6d059e0',
+    entrypoint: 'preferences',
+    flowBeginTime: 1711393758313,
+    flowId:
+      '4083592c5736512a96cea28ad68ae9c7ecc8f96298d394fe3430687531e703d2',
+    flowCompleteSignal: 'account.signed',
+    flowType: 'login',
+    service: 'sync',
+  };
+
+  const enabledConfig: MetricsRedisConfig = {
+    redis: {
+      metrics: {
+        enabled: true,
+        prefix: 'metrics:',
+        lifetime: 60,
+      } as any,
+    },
+  };
+
+  beforeEach(() => {
+    redisStub = {
+      exists: jest.fn(),
+      set: jest.fn(),
+      get: jest.fn(),
+      del: jest.fn(),
+    };
+
+    metricsRedis = new MetricsRedis(enabledConfig);
+    // Replace the internal redis client with our stub.
+    (metricsRedis as any).redis = redisStub;
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe('#add', () => {
+    it('should add data to the cache', async () => {
+      redisStub.exists.mockResolvedValue(0);
+      redisStub.set.mockResolvedValue('OK');
+
+      await metricsRedis.add(KEY, metricsContext);
+
+      expect(redisStub.exists).toHaveBeenCalledWith(KEY);
+      expect(redisStub.set).toHaveBeenCalledWith(
+        KEY,
+        JSON.stringify(metricsContext),
+        'EX',
+        60
+      );
+    });
+
+    it('should throw an error if key already exists', async () => {
+      redisStub.exists.mockResolvedValue(1);
+
+      await expect(metricsRedis.add(KEY, metricsContext)).rejects.toThrow(
+        'Key already exists'
+      );
+    });
+
+    it('should fail silently if the cache is not enabled', async () => {
+      redisStub.exists.mockResolvedValue(0);
+      (metricsRedis as any).enabled = false;
+
+      await metricsRedis.add(KEY, metricsContext);
+
+      expect(redisStub.set).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('#del', () => {
+    it('should delete data from the cache', async () => {
+      redisStub.del.mockResolvedValue(1);
+
+      await metricsRedis.del(KEY);
+
+      expect(redisStub.del).toHaveBeenCalledWith(KEY);
+    });
+
+    it('should fail silently if the cache is not enabled', async () => {
+      (metricsRedis as any).enabled = false;
+
+      await metricsRedis.del(KEY);
+
+      expect(redisStub.del).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('#get', () => {
+    it('should fetch data from the cache', async () => {
+      redisStub.get.mockResolvedValue(JSON.stringify(metricsContext));
+
+      const result = await metricsRedis.get(KEY);
+
+      expect(redisStub.get).toHaveBeenCalledWith(KEY);
+      expect(result).toEqual(metricsContext);
+    });
+
+    it('should return an empty object if an error occurs', async () => {
+      redisStub.get.mockRejectedValue(new Error('Test error'));
+
+      const result = await metricsRedis.get(KEY);
+
+      expect(redisStub.get).toHaveBeenCalledWith(KEY);
+      expect(result).toEqual({});
+    });
+
+    it('should return an empty object if not enabled', async () => {
+      (metricsRedis as any).enabled = false;
+
+      const result = await metricsRedis.get(KEY);
+
+      expect(redisStub.get).not.toHaveBeenCalled();
+      expect(result).toEqual({});
+    });
+  });
+});

packages/fxa-auth-server/lib/metrics/amplitude.spec.ts

@@ -0,0 +1,163 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+
+describe('monitoring', () => {
+  let mockInitMonitoring: jest.Mock;
+  let mockIgnoreErrors: jest.Mock;
+  let mockLog: jest.Mock;
+  let mockLogger: Record<string, jest.Mock>;
+  let mockHapiIntegration: jest.Mock;
+  let mockLinkedErrorsIntegration: jest.Mock;
+
+  beforeEach(() => {
+    jest.resetModules();
+
+    mockInitMonitoring = jest.fn();
+    mockIgnoreErrors = jest.fn();
+    mockLogger = {
+      info: jest.fn(),
+      error: jest.fn(),
+      warn: jest.fn(),
+      debug: jest.fn(),
+      trace: jest.fn(),
+    };
+    mockLog = jest.fn().mockReturnValue(mockLogger);
+    mockHapiIntegration = jest.fn().mockReturnValue({ name: 'Hapi' });
+    mockLinkedErrorsIntegration = jest
+      .fn()
+      .mockReturnValue({ name: 'LinkedErrors' });
+
+    jest.doMock('fxa-shared/monitoring', () => ({
+      initMonitoring: mockInitMonitoring,
+    }));
+    jest.doMock('../config', () => ({
+      config: {
+        getProperties: jest.fn().mockReturnValue({
+          log: { level: 'debug' },
+          sentry: { dsn: 'https://[email protected]/123' },
+        }),
+      },
+    }));
+    jest.doMock('./log', () => mockLog);
+    jest.doMock('../package.json', () => ({ version: '1.234.0' }), {
+      virtual: true,
+    });
+    jest.doMock('@fxa/accounts/errors', () => ({
+      ignoreErrors: mockIgnoreErrors,
+    }));
+    jest.doMock('@sentry/node', () => ({
+      hapiIntegration: mockHapiIntegration,
+      linkedErrorsIntegration: mockLinkedErrorsIntegration,
+    }));
+
+    // Requiring the module triggers the top-level initMonitoring() call.
+    require('./monitoring');
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('calls initMonitoring on module load', () => {
+    expect(mockInitMonitoring).toHaveBeenCalledTimes(1);
+
+    const callArg = mockInitMonitoring.mock.calls[0][0];
+
+    // Logger is the return value of require('./log')(level, name)
+    expect(callArg.logger).toBe(mockLogger);
+    expect(mockLog).toHaveBeenCalledWith('debug', 'configure-sentry');
+
+    // Config includes spread properties, release, eventFilters, integrations
+    expect(callArg.config).toEqual(
+      expect.objectContaining({
+        log: { level: 'debug' },
+        sentry: { dsn: 'https://[email protected]/123' },
+        release: '1.234.0',
+      })
+    );
+    expect(callArg.config.eventFilters).toHaveLength(1);
+    expect(typeof callArg.config.eventFilters[0]).toBe('function');
+    expect(callArg.config.integrations).toHaveLength(2);
+  });
+
+  it('passes Sentry integrations with correct configuration', () => {
+    expect(mockHapiIntegration).toHaveBeenCalledTimes(1);
+    expect(mockLinkedErrorsIntegration).toHaveBeenCalledWith({
+      key: 'jse_cause',
+    });
+  });
+
+  describe('filterSentryEvent', () => {
+    let filterSentryEvent: (event: any, hint?: any) => any;
+
+    beforeEach(() => {
+      // Extract the filterSentryEvent function from the initMonitoring call
+      const callArg = mockInitMonitoring.mock.calls[0][0];
+      filterSentryEvent = callArg.config.eventFilters[0];
+    });
+
+    it('returns null when ignoreErrors returns true', () => {
+      mockIgnoreErrors.mockReturnValue(true);
+
+      const event = { event_id: 'abc123' };
+      const hint = { originalException: new Error('ignored error') };
+
+      const result = filterSentryEvent(event, hint);
+
+      expect(result).toBeNull();
+      expect(mockIgnoreErrors).toHaveBeenCalledWith(hint.originalException);
+    });
+
+    it('returns the event when ignoreErrors returns false', () => {
+      mockIgnoreErrors.mockReturnValue(false);
+
+      const event = { event_id: 'def456' };
+      const hint = { originalException: new Error('real error') };
+
+      const result = filterSentryEvent(event, hint);
+
+      expect(result).toBe(event);
+      expect(mockIgnoreErrors).toHaveBeenCalledWith(hint.originalException);
+    });
+
+    it('returns the event when hint.originalException is null', () => {
+      const event = { event_id: 'ghi789' };
+      const hint = { originalException: null };
+
+      const result = filterSentryEvent(event, hint);
+
+      expect(result).toBe(event);
+      expect(mockIgnoreErrors).not.toHaveBeenCalled();
+    });
+
+    it('returns the event when hint.originalException is undefined', () => {
+      const event = { event_id: 'jkl012' };
+      const hint = { originalException: undefined };
+
+      const result = filterSentryEvent(event, hint);
+
+      expect(result).toBe(event);
+      expect(mockIgnoreErrors).not.toHaveBeenCalled();
+    });
+
+    it('returns the event when hint is undefined', () => {
+      const event = { event_id: 'mno345' };
+
+      const result = filterSentryEvent(event, undefined);
+
+      expect(result).toBe(event);
+      expect(mockIgnoreErrors).not.toHaveBeenCalled();
+    });
+
+    it('returns the event when hint is null', () => {
+      const event = { event_id: 'pqr678' };
+
+      const result = filterSentryEvent(event, null);
+
+      expect(result).toBe(event);
+      expect(mockIgnoreErrors).not.toHaveBeenCalled();
+    });
+  });
+});