@velocitycareerlabs/server-careerwallet 1.25.0-dev-build.12642c864

package/test/push-controller.test.js

@@ -0,0 +1,733 @@
+const { mongoDb } = require('@spencejs/spence-mongo-repos');
+const { ObjectId } = require('mongodb');
+const { nanoid } = require('nanoid');
+const { errorResponseMatcher } = require('@velocitycareerlabs/tests-helpers');
+const initDevicesFactory = require('./factories/devices-factory');
+const initAccountsFactory = require('./factories/accounts-factory');
+const buildFastify = require('./helpers/careerwallet-build-fastify');
+const { accountsRepoPlugin } = require('../src/entities');
+
+const {
+  generateNotification,
+} = require('../src/controllers/api/v0.6/push/notification-types');
+
+const testDID = 'test-did';
+
+const mockSend = jest.fn().mockResolvedValue(true);
+const mockMessaging = jest.fn(() => ({
+  send: mockSend,
+}));
+const mockInitializeApp = jest.fn();
+const mockCredential = jest.fn();
+
+const ttlSeconds = 60 * 60 * 24;
+const notificationObj = {
+  body: 'You have new credential offers.',
+  title: 'New credential offer',
+};
+const sendPayloadExpectation = (deviceId, notification, data) => ({
+  token: deviceId,
+  ...(!!data && { data }),
+  notification: notification || notificationObj,
+  android: {
+    ttl: ttlSeconds * 1000,
+    priority: 'high',
+    notification: {
+      sound: 'default',
+      icon: 'https://docs.velocitycareerlabs.io/Logos/vcl-app-push-logo.png',
+    },
+  },
+  apns: {
+    headers: {
+      'apns-priority': '5',
+    },
+    payload: {
+      aps: {
+        sound: 'default',
+        icon: 'https://docs.velocitycareerlabs.io/Logos/vcl-app-push-logo.png',
+        'content-available': 1,
+      },
+    },
+  },
+  webpush: {
+    headers: {
+      TTL: `${ttlSeconds}`,
+      Urgency: 'high',
+    },
+  },
+});
+
+jest.mock('../src/controllers/api/v0.6/push/push-gateway-auth', () => ({
+  pushGatewayAuth: () => Promise.resolve(),
+}));
+
+jest.mock('firebase-admin', () => {
+  return {
+    initializeApp: mockInitializeApp,
+    credential: { cert: mockCredential },
+    messaging: mockMessaging,
+  };
+});
+
+describe('push endpoints', () => {
+  let fastify;
+  let accountsRepo;
+  let persistDevices;
+  let persistAccounts;
+  let device;
+  let account;
+  let pushToken;
+
+  beforeAll(async () => {
+    fastify = buildFastify();
+    await fastify.ready();
+    accountsRepo = await accountsRepoPlugin(fastify)({
+      log: fastify.log,
+      config: fastify.config,
+    });
+    ({ persistAccounts } = initAccountsFactory(fastify));
+    ({ persistDevices } = initDevicesFactory(fastify));
+  });
+
+  afterAll(async () => {
+    await mongoDb().collection('devices').deleteMany({});
+    await mongoDb().collection('accounts').deleteMany({});
+    await mongoDb().collection('notifications').deleteMany({});
+
+    await fastify.close();
+  });
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('trigger push on oracle', () => {
+    beforeEach(async () => {
+      pushToken = nanoid();
+      account = await persistAccounts({
+        pushTokens: {
+          [pushToken]: {
+            did: testDID,
+            date: new Date(),
+          },
+        },
+      });
+      device = await persistDevices({
+        accountId: new ObjectId(account._id),
+        pushActivated: true,
+      });
+    });
+
+    it('should return 400 when id is missing', async () => {
+      const response = await fastify.injectJson({
+        method: 'POST',
+        url: '/api/v0.6/push',
+        payload: {
+          pushToken: device.pushToken,
+          data: {
+            notificationType: 'NewOffersReady',
+          },
+        },
+      });
+
+      expect(response.statusCode).toEqual(400);
+    });
+
+    it('should return 400 when notificationType is missing', async () => {
+      const response = await fastify.injectJson({
+        method: 'POST',
+        url: '/api/v0.6/push',
+        payload: {
+          id: new ObjectId(),
+          pushToken: device.pushToken,
+          data: {},
+        },
+      });
+
+      expect(response.statusCode).toEqual(400);
+    });
+
+    it('should return 400 when notificationType is not correct', async () => {
+      const response = await fastify.injectJson({
+        method: 'POST',
+        url: '/api/v0.6/push',
+        payload: {
+          id: new ObjectId(),
+          pushToken: device.pushToken,
+          data: {
+            notificationType: 'WrongType',
+          },
+        },
+      });
+
+      expect(response.statusCode).toEqual(400);
+    });
+
+    it('should run the generateNotification function without errors', async () => {
+      const data = {};
+      const message = undefined;
+      const notification = generateNotification(data, message);
+
+      expect(notification).toEqual(undefined);
+    });
+    it('should generate a correct notification accordingly to the NewOffersReady type', async () => {
+      [
+        {
+          body: 'You have new credential offers.',
+          count: 4,
+        },
+        {
+          body: 'You have new credential offers.',
+          count: '1',
+        },
+      ].forEach(({ body, count }) => {
+        const data = {
+          notificationType: 'NewOffersReady',
+          credentialTypes: ['EducationDegree', 'PastEmploymentPosition'],
+          count,
+        };
+        const message =
+          'This custom message is gonna be ignored for this notification type';
+        const notification = generateNotification(data, message);
+
+        expect(notification).toEqual({
+          body,
+          title: 'New credential offer',
+        });
+      });
+    });
+
+    it('should generate a correct notification accordingly to the CredentialReplaced type', async () => {
+      const data = {
+        notificationType: 'CredentialReplaced',
+        credentialTypes: ['EducationDegree', 'PastEmploymentPosition'],
+      };
+      const message = undefined;
+      const notification = generateNotification(data, message);
+
+      expect(notification).toEqual({
+        body: 'Your EducationDegree credential can be updated. Tap here to receive the update.',
+        title: 'Updated credential available',
+      });
+    });
+
+    it('should generate a correct notification accordingly to the CredentialReplaced type with the custom message', async () => {
+      const data = {
+        notificationType: 'CredentialReplaced',
+        credentialTypes: ['EducationDegree', 'PastEmploymentPosition'],
+      };
+      const message =
+        'This custom message is gonna be showed instead of the deafault one.';
+      const notification = generateNotification(data, message);
+
+      expect(notification).toEqual({
+        body: 'This custom message is gonna be showed instead of the deafault one.',
+        title: 'Updated credential available',
+      });
+    });
+
+    it('should generate a correct notification accordingly to the CredentialRevoked type', async () => {
+      const data = {
+        notificationType: 'CredentialRevoked',
+        credentialTypes: [
+          'CurrentEmploymentPosition',
+          'PastEmploymentPosition',
+        ],
+      };
+      const message = undefined;
+      const notification = generateNotification(data, message);
+
+      expect(notification).toEqual({
+        body: 'Your CurrentEmploymentPosition credential has been revoked.',
+        title: 'Credential revoked',
+      });
+    });
+
+    it('should generate a correct notification accordingly to the PresentationVerified type', async () => {
+      const data = {
+        notificationType: 'PresentationVerified',
+        credentialTypes: ['EducationDegree'],
+      };
+      const message = undefined;
+      const notification = generateNotification(data, message);
+
+      expect(notification).toEqual({
+        body: 'Credentials that you shared have been verified',
+        title: 'Credentials verified',
+      });
+    });
+
+    it('should return 400 when the data property is missing', async () => {
+      const response = await fastify.injectJson({
+        method: 'POST',
+        url: '/api/v0.6/push',
+        payload: {
+          id: new ObjectId(),
+          pushToken: device.pushToken,
+        },
+      });
+
+      expect(response.statusCode).toEqual(400);
+    });
+
+    it('should return 400 when pushToken is missing', async () => {
+      const response = await fastify.injectJson({
+        method: 'POST',
+        url: '/api/v0.6/push',
+        payload: {
+          id: new ObjectId(),
+          data: {
+            notificationType: 'NewOffersReady',
+          },
+        },
+      });
+
+      expect(response.statusCode).toEqual(400);
+    });
+
+    it('should return 204 when notification is sent', async () => {
+      const filter = {
+        [`pushTokens.${pushToken}`]: { $exists: true },
+      };
+      const accountWithUsedPushToken = await accountsRepo.findOne({
+        filter,
+      });
+      expect(accountWithUsedPushToken).toBeDefined();
+      const response = await fastify.injectJson({
+        method: 'POST',
+        url: '/api/v0.6/push',
+        payload: {
+          id: new ObjectId(),
+          pushToken,
+          data: {
+            notificationType: 'NewOffersReady',
+          },
+        },
+      });
+      expect(response.statusCode).toEqual(204);
+      expect(mockMessaging).toHaveBeenCalledTimes(1);
+      expect(mockSend).toHaveBeenCalledTimes(1);
+      expect(mockSend).toHaveBeenCalledWith(
+        sendPayloadExpectation(device.deviceId, null, {
+          count: '0',
+          credentialTypes: '[]',
+          notificationId: expect.any(String),
+          notificationType: 'NewOffersReady',
+        })
+      );
+      const accountWithoutUsedPushToken = await accountsRepo.findOne({
+        filter,
+      });
+      expect(accountWithoutUsedPushToken).toStrictEqual(
+        accountWithUsedPushToken
+      );
+    });
+
+    it('should have the notificationId in data when notification sent', async () => {
+      const response = await fastify.injectJson({
+        method: 'POST',
+        url: '/api/v0.6/push',
+        payload: {
+          id: new ObjectId(),
+          pushToken,
+          data: {
+            count: 2,
+            notificationType: 'NewOffersReady',
+            credentialTypes: ['EducationDegree', 'PastEmploymentPosition'],
+          },
+        },
+      });
+
+      expect(response.statusCode).toEqual(204);
+      expect(mockMessaging).toHaveBeenCalledTimes(1);
+      expect(mockSend).toHaveBeenCalledTimes(1);
+      expect(mockSend).toHaveBeenCalledWith(
+        sendPayloadExpectation(device.deviceId, null, {
+          count: '2',
+          credentialTypes: '["EducationDegree","PastEmploymentPosition"]',
+          notificationId: expect.stringMatching(/^[0-9a-fA-F]{24}$/),
+          notificationType: 'NewOffersReady',
+        })
+      );
+    });
+
+    it('should have a saved notification on 204 when notification is sent', async () => {
+      await mongoDb().collection('notifications').deleteMany({});
+
+      const response = await fastify.injectJson({
+        method: 'POST',
+        url: '/api/v0.6/push',
+        payload: {
+          id: new ObjectId(),
+          pushToken,
+          data: {
+            count: 1,
+            notificationType: 'NewOffersReady',
+          },
+        },
+      });
+      const notifications = await mongoDb()
+        .collection('notifications')
+        .find({})
+        .toArray();
+
+      expect(notifications.length).toEqual(1);
+      expect(notifications[0].data.notificationType).toEqual('NewOffersReady');
+      expect(response.statusCode).toEqual(204);
+      expect(mockMessaging).toHaveBeenCalledTimes(1);
+      expect(mockSend).toHaveBeenCalledTimes(1);
+    });
+
+    it('should have a saved notification on 204 and send notification when there is no pushActivated flag', async () => {
+      await mongoDb().collection('notifications').deleteMany({});
+      const response = await fastify.injectJson({
+        method: 'POST',
+        url: '/api/v0.6/push',
+        payload: {
+          id: new ObjectId(),
+          pushToken,
+          data: {
+            notificationType: 'NewOffersReady',
+          },
+        },
+      });
+      const notifications = await mongoDb()
+        .collection('notifications')
+        .find({})
+        .toArray();
+
+      expect(notifications.length).toEqual(1);
+      expect(notifications[0].data.notificationType).toEqual('NewOffersReady');
+      expect(response.statusCode).toEqual(204);
+
+      expect(mockMessaging).toHaveBeenCalledTimes(1);
+      expect(mockSend).toHaveBeenCalledTimes(1);
+    });
+
+    it('should have a saved notification on 204 and send notification when pushActivated flag is true', async () => {
+      await mongoDb().collection('notifications').deleteMany({});
+      const pushTokenForPushActivated = nanoid();
+      const accountForPushActivated = await persistAccounts({
+        pushTokens: {
+          [pushTokenForPushActivated]: {
+            did: testDID,
+            date: new Date(),
+          },
+        },
+      });
+      await persistDevices({
+        accountId: new ObjectId(accountForPushActivated._id),
+        pushActivated: true,
+      });
+      const response = await fastify.injectJson({
+        method: 'POST',
+        url: '/api/v0.6/push',
+        payload: {
+          id: new ObjectId(),
+          pushToken: pushTokenForPushActivated,
+          data: {
+            notificationType: 'NewOffersReady',
+          },
+        },
+      });
+      const notifications = await mongoDb()
+        .collection('notifications')
+        .find({})
+        .toArray();
+
+      expect(notifications.length).toEqual(1);
+      expect(notifications[0].data.notificationType).toEqual('NewOffersReady');
+      expect(response.statusCode).toEqual(204);
+
+      expect(mockMessaging).toHaveBeenCalledTimes(1);
+      expect(mockSend).toHaveBeenCalledTimes(1);
+    });
+
+    it('should have a saved notification on 204 but not send notification when pushActivated flag is false', async () => {
+      await mongoDb().collection('notifications').deleteMany({});
+      const pushTokenForNonPushAxtivated = nanoid();
+      const accountForNonPushActivated = await persistAccounts({
+        pushTokens: {
+          [pushTokenForNonPushAxtivated]: {
+            did: testDID,
+            date: new Date(),
+          },
+        },
+      });
+      await persistDevices({
+        accountId: new ObjectId(accountForNonPushActivated._id),
+        pushActivated: false,
+      });
+      const response = await fastify.injectJson({
+        method: 'POST',
+        url: '/api/v0.6/push',
+        payload: {
+          id: new ObjectId(),
+          pushToken: pushTokenForNonPushAxtivated,
+          data: {
+            notificationType: 'NewOffersReady',
+          },
+        },
+      });
+      const notifications = await mongoDb()
+        .collection('notifications')
+        .find({})
+        .toArray();
+
+      expect(notifications.length).toEqual(1);
+      expect(notifications[0].data.notificationType).toEqual('NewOffersReady');
+      expect(response.statusCode).toEqual(204);
+
+      expect(mockMessaging).toHaveBeenCalledTimes(0);
+      expect(mockSend).toHaveBeenCalledTimes(0);
+    });
+
+    it('should have a saved notifications on 204 and send notifications when pushActivated flag is true for multiple devices', async () => {
+      await mongoDb().collection('notifications').deleteMany({});
+      const pushTokenForPushActivated = nanoid();
+      const accountForPushActivated = await persistAccounts({
+        pushTokens: {
+          [pushTokenForPushActivated]: {
+            did: testDID,
+            date: `${new Date()}`,
+          },
+        },
+      });
+      const deviceFirst = await persistDevices({
+        accountId: new ObjectId(accountForPushActivated._id),
+        pushActivated: true,
+      });
+      const deviceSecond = await persistDevices({
+        accountId: new ObjectId(accountForPushActivated._id),
+        pushActivated: true,
+      });
+
+      // Another account to check that push notification goes only for first one
+      const anotherPushTokenForPushActivated = nanoid();
+      const anotherAccountForPushActivated = await persistAccounts({
+        pushTokens: {
+          [anotherPushTokenForPushActivated]: {
+            did: testDID,
+            date: `${new Date()}`,
+          },
+        },
+      });
+      await persistDevices({
+        accountId: new ObjectId(anotherAccountForPushActivated._id),
+        pushActivated: true,
+      });
+
+      const response = await fastify.injectJson({
+        method: 'POST',
+        url: '/api/v0.6/push',
+        payload: {
+          id: new ObjectId(),
+          pushToken: pushTokenForPushActivated,
+          data: {
+            notificationType: 'NewOffersReady',
+          },
+        },
+      });
+      const notifications = await mongoDb()
+        .collection('notifications')
+        .find({})
+        .toArray();
+
+      expect(notifications.length).toEqual(2);
+      expect(notifications[0].data.notificationType).toEqual('NewOffersReady');
+      expect(notifications[1].data.notificationType).toEqual('NewOffersReady');
+      expect(response.statusCode).toEqual(204);
+
+      expect(mockMessaging).toHaveBeenCalledTimes(2);
+      expect(mockSend).toHaveBeenCalledTimes(2);
+      expect(mockSend).toHaveBeenNthCalledWith(
+        1,
+        sendPayloadExpectation(deviceSecond.deviceId, null, {
+          count: '0',
+          credentialTypes: '[]',
+          notificationId: expect.any(String),
+          notificationType: 'NewOffersReady',
+        })
+      );
+      expect(mockSend).toHaveBeenNthCalledWith(
+        2,
+        sendPayloadExpectation(deviceFirst.deviceId, null, {
+          count: '0',
+          credentialTypes: '[]',
+          notificationId: expect.any(String),
+          notificationType: 'NewOffersReady',
+        })
+      );
+
+      const firstAccount = await accountsRepo.findOne({
+        filter: {
+          [`pushTokens.${pushTokenForPushActivated}`]: { $exists: true },
+        },
+      });
+      const secondAccount = await accountsRepo.findOne({
+        filter: {
+          [`pushTokens.${anotherPushTokenForPushActivated}`]: { $exists: true },
+        },
+      });
+      expect(firstAccount).toStrictEqual({
+        ...accountForPushActivated,
+        _id: new ObjectId(accountForPushActivated._id),
+        createdAt: expect.any(Date),
+        updatedAt: expect.any(Date),
+      });
+      expect(secondAccount).toStrictEqual({
+        ...anotherAccountForPushActivated,
+        _id: new ObjectId(anotherAccountForPushActivated._id),
+        createdAt: expect.any(Date),
+        updatedAt: expect.any(Date),
+      });
+    });
+
+    it('should have a saved notification on 204 and send notification when pushActivated flag is true for old devices with pushToken', async () => {
+      await mongoDb().collection('notifications').deleteMany({});
+      await mongoDb().collection('accounts').deleteMany({});
+      await persistDevices({
+        pushActivated: true,
+        pushToken,
+      });
+      const response = await fastify.injectJson({
+        method: 'POST',
+        url: '/api/v0.6/push',
+        payload: {
+          id: new ObjectId(),
+          pushToken,
+          data: {
+            notificationType: 'NewOffersReady',
+          },
+        },
+      });
+      const notifications = await mongoDb()
+        .collection('notifications')
+        .find({})
+        .toArray();
+
+      expect(notifications.length).toEqual(1);
+      expect(notifications[0].data.notificationType).toEqual('NewOffersReady');
+      expect(response.statusCode).toEqual(204);
+
+      expect(mockMessaging).toHaveBeenCalledTimes(1);
+      expect(mockSend).toHaveBeenCalledTimes(1);
+    });
+
+    it('should return 404 when device not found', async () => {
+      const response = await fastify.injectJson({
+        method: 'POST',
+        url: '/api/v0.6/push',
+        payload: {
+          id: new ObjectId(),
+          pushToken: 'some-token',
+          data: {
+            notificationType: 'NewOffersReady',
+          },
+        },
+      });
+      expect(response.statusCode).toEqual(404);
+      expect(response.json).toEqual(
+        errorResponseMatcher({
+          errorCode: 'missing_error_code',
+          error: 'Not Found',
+          message: 'No device registered for token some-token',
+          statusCode: 404,
+        })
+      );
+      expect(mockInitializeApp).toHaveBeenCalledTimes(0);
+      expect(mockMessaging).toHaveBeenCalledTimes(0);
+      expect(mockSend).toHaveBeenCalledTimes(0);
+    });
+
+    it('should return 502 when firebase.send throws with an error', async () => {
+      mockSend.mockRejectedValueOnce(new Error('test sendToDevice error'));
+      const response = await fastify.injectJson({
+        method: 'POST',
+        url: '/api/v0.6/push',
+        payload: {
+          id: new ObjectId(),
+          pushToken,
+          data: {
+            notificationType: 'NewOffersReady',
+          },
+        },
+      });
+      expect(response.statusCode).toEqual(204);
+    });
+
+    it('should return 200 generate is called', async () => {
+      const filter = {
+        [`pushTokens.${pushToken}`]: { $exists: true },
+      };
+      const accountWithUsedPushToken = await accountsRepo.findOne({
+        filter,
+      });
+      expect(accountWithUsedPushToken).toBeDefined();
+      const response = await fastify.injectJson({
+        method: 'POST',
+        url: '/api/v0.6/push/generate',
+        payload: {
+          id: new ObjectId(),
+          pushToken,
+          content: {
+            title: 'notification title',
+            body: 'notification body',
+          },
+        },
+      });
+      expect(response.statusCode).toEqual(200);
+      expect(mockMessaging).toHaveBeenCalledTimes(1);
+      expect(mockSend).toHaveBeenCalledTimes(1);
+      expect(mockSend).toHaveBeenCalledWith(
+        sendPayloadExpectation(
+          device.deviceId,
+          {
+            body: 'notification body',
+            title: 'notification title',
+          },
+          null
+        )
+      );
+      const accountWithoutUsedPushToken = await accountsRepo.findOne({
+        filter,
+      });
+      expect(accountWithoutUsedPushToken).toStrictEqual(
+        accountWithUsedPushToken
+      );
+    });
+
+    it('should return 200 generate is called for old devices with pushToken', async () => {
+      await mongoDb().collection('accounts').deleteMany({});
+      const newDevice = await persistDevices({
+        pushActivated: true,
+        pushToken,
+      });
+      const response = await fastify.injectJson({
+        method: 'POST',
+        url: '/api/v0.6/push/generate',
+        payload: {
+          id: new ObjectId(),
+          pushToken,
+          content: {
+            title: 'notification title',
+            body: 'notification body',
+          },
+        },
+      });
+      expect(response.statusCode).toEqual(200);
+      expect(mockMessaging).toHaveBeenCalledTimes(1);
+      expect(mockSend).toHaveBeenCalledTimes(1);
+      expect(mockSend).toHaveBeenCalledWith(
+        sendPayloadExpectation(
+          newDevice.deviceId,
+          {
+            body: 'notification body',
+            title: 'notification title',
+          },
+          null
+        )
+      );
+    });
+  });
+});