Merge pull request #20238 from mozilla/fxa-12620

feat(auth-server): migrate auth server profile mocha tests to jest

Author: vbudhram

packages/fxa-auth-server/lib/google-maps-services.spec.ts

@@ -0,0 +1,268 @@
+/* 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 sinon from 'sinon';
+import Sentry from '@sentry/node';
+import { default as Container } from 'typedi';
+
+const sentryModule = require('./sentry');
+const { mockLog } = require('../test/mocks');
+const { GoogleMapsService } = require('./google-maps-services');
+const { AuthLogger, AppConfig } = require('./types');
+
+function deepCopy(object: any) {
+  return JSON.parse(JSON.stringify(object));
+}
+
+const geocodeResultMany = {
+  data: {
+    results: [
+      {
+        address_components: [
+          {
+            long_name: 'Maryland',
+            short_name: 'MD',
+            types: ['administrative_area_level_1', 'political'],
+          },
+          {
+            long_name: '11111',
+            short_name: '11111',
+            types: ['postal_code'],
+          },
+        ],
+      },
+      {
+        address_components: [
+          {
+            long_name: 'New York',
+            short_name: 'NY',
+            types: ['administrative_area_level_1', 'political'],
+          },
+        ],
+      },
+    ],
+    status: 'OK',
+  },
+};
+
+const geocodeResultWithoutState = {
+  data: {
+    results: [
+      {
+        address_components: [
+          {
+            long_name: '20639',
+            short_name: '20639',
+            types: ['postal_code'],
+          },
+          {
+            long_name: 'United States',
+            short_name: 'US',
+            types: ['country', 'political'],
+          },
+        ],
+      },
+    ],
+    status: 'OK',
+  },
+};
+
+const geocodeResultDEZip = {
+  data: {
+    results: [
+      {
+        address_components: [
+          {
+            long_name: 'Saxony-Anhalt',
+            short_name: 'SA',
+            types: ['administrative_area_level_1', 'political'],
+          },
+        ],
+      },
+    ],
+    status: 'OK',
+  },
+};
+
+const noResult = {
+  data: {
+    results: [],
+    status: 'ZERO_RESULTS',
+  },
+};
+
+const noResultWithError = {
+  data: {
+    results: [],
+    status: 'UNKNOWN_ERROR',
+    error_message: 'An unknown error has occurred',
+  },
+};
+
+const mockConfig = {
+  googleMapsApiKey: 'foo',
+};
+
+let googleMapsServices: any;
+let googleClient: any;
+
+describe('GoogleMapsServices', () => {
+  let log: any;
+
+  beforeEach(() => {
+    log = mockLog();
+    Container.set(AuthLogger, log);
+    Container.set(AppConfig, mockConfig);
+    googleMapsServices = new GoogleMapsService();
+    googleMapsServices.client = googleClient = {};
+  });
+
+  afterEach(() => {
+    sinon.restore();
+    Container.reset();
+  });
+
+  describe('getStateFromZip', () => {
+    it('returns location for zip code and country', async () => {
+      const expectedResult = 'SA';
+      const expectedAddress = '06369, Germany';
+      googleClient.geocode = sinon.stub().resolves(geocodeResultDEZip);
+
+      const actualResult = await googleMapsServices.getStateFromZip(
+        '06369',
+        'DE'
+      );
+      expect(actualResult).toBe(expectedResult);
+      expect(googleClient.geocode.calledOnce).toBe(true);
+      expect(
+        googleClient.geocode.getCall(0).args[0].params.address
+      ).toBe(expectedAddress);
+    });
+
+    it('returns location for zip code and country if more than 1 result is returned with matching states', async () => {
+      const geocodeResultManyMatchingStates = deepCopy(geocodeResultMany);
+      geocodeResultManyMatchingStates.data.results[1].address_components[0].short_name =
+        'MD';
+      const expectedResult = 'MD';
+      const expectedAddress = '11111, United States of America';
+      googleClient.geocode = sinon
+        .stub()
+        .resolves(geocodeResultManyMatchingStates);
+
+      const actualResult = await googleMapsServices.getStateFromZip(
+        '11111',
+        'US'
+      );
+      expect(actualResult).toBe(expectedResult);
+      expect(googleClient.geocode.calledOnce).toBe(true);
+      expect(
+        googleClient.geocode.getCall(0).args[0].params.address
+      ).toBe(expectedAddress);
+    });
+
+    it('Throws error if more than 1 result is returned with mismatching states', async () => {
+      const expectedMessage = 'Could not find unique results. (22222, Germany)';
+      googleClient.geocode = sinon.stub().resolves(geocodeResultMany);
+
+      try {
+        await googleMapsServices.getStateFromZip('22222', 'DE');
+        throw new Error('Expected error to be thrown');
+      } catch (err) {
+        expect(
+          googleMapsServices.log.error.getCall(0).args[1].error.message
+        ).toBe(expectedMessage);
+      }
+    });
+
+    it('Throws error for invalid country code', async () => {
+      const expectedMessage =
+        'Invalid country (Germany). Only ISO 3166-1 alpha-2 country codes are supported.';
+
+      try {
+        await googleMapsServices.getStateFromZip('11111', 'Germany');
+        throw new Error('Expected error to be thrown');
+      } catch (err) {
+        expect(
+          googleMapsServices.log.error.getCall(0).args[1].error.message
+        ).toBe(expectedMessage);
+      }
+    });
+
+    it('Throws error for zip code without state', async () => {
+      const expectedMessage = 'State could not be found. (11111, Germany)';
+      googleClient.geocode = sinon.stub().resolves(geocodeResultWithoutState);
+
+      try {
+        await googleMapsServices.getStateFromZip('11111', 'DE');
+        throw new Error('Expected error to be thrown');
+      } catch (err) {
+        expect(
+          googleMapsServices.log.error.getCall(0).args[1].error.message
+        ).toBe(expectedMessage);
+      }
+    });
+
+    it('Throws error if no results were found', async () => {
+      const expectedMessage =
+        'Could not find any results for address. (11111, Germany)';
+      googleClient.geocode = sinon.stub().resolves(noResult);
+
+      try {
+        await googleMapsServices.getStateFromZip('11111', 'DE');
+        throw new Error('Expected error to be thrown');
+      } catch (err) {
+        expect(
+          googleMapsServices.log.error.getCall(0).args[1].error.message
+        ).toBe(expectedMessage);
+      }
+    });
+
+    it('Throws error for bad status code', async () => {
+      const expectedMessage =
+        'UNKNOWN_ERROR - An unknown error has occurred. (11111, Germany)';
+      googleClient.geocode = sinon.stub().resolves(noResultWithError);
+
+      const scopeContextSpy = sinon.fake();
+      const scopeSpy = {
+        setContext: scopeContextSpy,
+      };
+      sinon.replace(Sentry, 'withScope', ((fn: any) => fn(scopeSpy)) as any);
+      sinon.stub(sentryModule, 'reportSentryMessage').returns({});
+
+      try {
+        await googleMapsServices.getStateFromZip('11111', 'DE');
+        throw new Error('Expected error to be thrown');
+      } catch (err) {
+        expect(
+          googleMapsServices.log.error.getCall(0).args[1].error.message
+        ).toBe(expectedMessage);
+        expect(scopeContextSpy.calledOnce).toBe(true);
+        expect(sentryModule.reportSentryMessage.calledOnce).toBe(true);
+      }
+    });
+
+    it('Throws error when GeocodeData fails', async () => {
+      const expectedMessage = 'Geocode is not available';
+      googleClient.geocode = sinon.stub().rejects(new Error(expectedMessage));
+
+      const scopeContextSpy = sinon.fake();
+      const scopeSpy = {
+        setContext: scopeContextSpy,
+      };
+      sinon.replace(Sentry, 'withScope', ((fn: any) => fn(scopeSpy)) as any);
+      sinon.stub(sentryModule, 'reportSentryMessage').returns({});
+
+      try {
+        await googleMapsServices.getStateFromZip('11111', 'DE');
+        throw new Error('Expected error to be thrown');
+      } catch (err) {
+        expect(
+          googleMapsServices.log.error.getCall(0).args[1].error.message
+        ).toBe(expectedMessage);
+        expect(scopeContextSpy.calledOnce).toBe(true);
+        expect(sentryModule.reportSentryMessage.calledOnce).toBe(true);
+      }
+    });
+  });
+});

packages/fxa-auth-server/lib/profile/updates.spec.ts

@@ -0,0 +1,87 @@
+/* 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 sinon from 'sinon';
+import { EventEmitter } from 'events';
+
+const { mockDB, mockLog } = require('../../test/mocks');
+const profileUpdates = require('./updates');
+
+const mockDeliveryQueue = new EventEmitter();
+(mockDeliveryQueue as any).start = function start() {};
+
+function mockMessage(msg: any) {
+  msg.del = sinon.spy();
+  return msg;
+}
+
+let pushShouldThrow = false;
+const mockPush = {
+  notifyProfileUpdated: sinon.spy((uid: string) => {
+    expect(typeof uid).toBe('string');
+    if (pushShouldThrow) {
+      throw new Error('oops');
+    }
+    return Promise.resolve();
+  }),
+};
+
+function mockProfileUpdates(log: any) {
+  return profileUpdates(log)(mockDeliveryQueue, mockPush, mockDB());
+}
+
+describe('profile updates', () => {
+  beforeEach(() => {
+    mockPush.notifyProfileUpdated.resetHistory();
+    pushShouldThrow = false;
+  });
+
+  it('should log errors', async () => {
+    pushShouldThrow = true;
+    const log = mockLog();
+    await mockProfileUpdates(log).handleProfileUpdated(
+      mockMessage({
+        uid: 'bogusuid',
+      })
+    );
+    expect(mockPush.notifyProfileUpdated.callCount).toBe(1);
+    expect(log.error.callCount).toBe(1);
+  });
+
+  it('should send notifications', async () => {
+    const log = mockLog();
+    const uid = '1e2122ba';
+    const email = '[email protected]';
+    const locale = 'en-US';
+    const metricsEnabled = true;
+    const totpEnabled = false;
+    const accountDisabled = false;
+    const accountLocked = false;
+
+    await mockProfileUpdates(log).handleProfileUpdated(
+      mockMessage({
+        uid,
+        email,
+        locale,
+        metricsEnabled,
+        totpEnabled,
+        accountDisabled,
+        accountLocked,
+      })
+    );
+
+    expect(log.error.callCount).toBe(0);
+    expect(mockPush.notifyProfileUpdated.callCount).toBe(1);
+    const args = mockPush.notifyProfileUpdated.getCall(0).args;
+    expect(args[0]).toBe(uid);
+
+    expect(
+      log.notifyAttachedServices.calledWithExactly(
+        'profileDataChange',
+        {},
+        { uid }
+      )
+    ).toBe(true);
+  });
+});