@openstax/ts-utils 1.33.1 → 1.34.0

package/packages/utils/src/services/accountsGateway/index.spec.ts

@@ -0,0 +1,518 @@
+import { v4 as uuid } from 'uuid';
+import { Level, Logger } from '../logger';
+import { AccountsGateway, accountsGateway, Config } from '.';
+
+afterEach(() => {
+  jest.clearAllMocks();
+});
+
+describe('accountsGateway', () => {
+  let accounts: AccountsGateway;
+  let fetchSpy: jest.SpyInstance;
+  let mockLogEvent: jest.SpyInstance;
+  let logger: Logger;
+  const config = {
+    accounts: {
+      accountsBase: 'accountsBaseString',
+      accountsAuthToken: 'accountsAuthTokenString',
+    } as Config
+  };
+
+  beforeEach(() => {
+    fetchSpy = jest.fn();
+    mockLogEvent = jest.fn();
+    logger = { logEvent: mockLogEvent } as any;
+    accounts = accountsGateway({fetch: fetchSpy as any})(config)({logger});
+  });
+
+  describe('findUser', () => {
+    const platformId = 'aac7d4b1-99d5-481e-a765-93f4caf87df2';
+    const platformUserId = 'f069ab0b-2c99-4914-804d-d0d10fb4a7c4';
+    const uuid = '3f5d0860-e573-4c45-8d56-10a32cfe70e1';
+    const external_id = `${platformId}/${platformUserId}`;
+    const is_test = true;
+
+    const findUserByExternalIdRequest = { external_id, sso: 'true' };
+    const findUserByUuidRequest = { uuid };
+    const findUserResponse = { id: 123, uuid, external_ids: [ external_id ], is_test, sso: 'SomeToken' };
+
+    it('finds a user in OpenStax Accounts by external_id and returns their SSO token and info', async() => {
+      fetchSpy.mockReturnValueOnce(Promise.resolve({json: async() => findUserResponse, status: 200}));
+      expect(await accounts.findUser(findUserByExternalIdRequest)).toEqual(findUserResponse);
+      expect(fetchSpy.mock.calls).toMatchInlineSnapshot(`
+[
+  [
+    "accountsBaseString/api/user/find",
+    {
+      "body": "{"external_id":"aac7d4b1-99d5-481e-a765-93f4caf87df2/f069ab0b-2c99-4914-804d-d0d10fb4a7c4","sso":"true"}",
+      "headers": {
+        "Authorization": "Bearer accountsAuthTokenString",
+      },
+      "method": "POST",
+    },
+  ],
+]
+`);
+    });
+
+    it('finds a user in OpenStax Accounts by uuid and returns their external_ids', async() => {
+      fetchSpy.mockReturnValueOnce(Promise.resolve({json: async() => findUserResponse, status: 200}));
+      expect(await accounts.findUser(findUserByUuidRequest)).toEqual(findUserResponse);
+      expect(fetchSpy.mock.calls).toMatchInlineSnapshot(`
+[
+  [
+    "accountsBaseString/api/user/find",
+    {
+      "body": "{"uuid":"3f5d0860-e573-4c45-8d56-10a32cfe70e1"}",
+      "headers": {
+        "Authorization": "Bearer accountsAuthTokenString",
+      },
+      "method": "POST",
+    },
+  ],
+]
+`);
+    });
+
+    it('returns undefined if Accounts returns status code 404', async() => {
+      fetchSpy.mockReturnValueOnce(Promise.resolve({json: async() => ({}), status: 404}));
+      expect(await accounts.findUser(findUserByExternalIdRequest)).toBeUndefined();
+      expect(fetchSpy.mock.calls).toMatchInlineSnapshot(`
+[
+  [
+    "accountsBaseString/api/user/find",
+    {
+      "body": "{"external_id":"aac7d4b1-99d5-481e-a765-93f4caf87df2/f069ab0b-2c99-4914-804d-d0d10fb4a7c4","sso":"true"}",
+      "headers": {
+        "Authorization": "Bearer accountsAuthTokenString",
+      },
+      "method": "POST",
+    },
+  ],
+]
+`);
+    });
+
+    it('throws an error if Accounts returns an unexpected status code', async() => {
+      fetchSpy.mockReturnValueOnce(Promise.resolve({json: async() => ({}), status: 409}));
+      await expect(accounts.findUser(findUserByUuidRequest)).rejects.toThrow(
+        'Received unexpected status code 409 for Accounts API call: POST accountsBaseString/api/user/find'
+      );
+    });
+  });
+
+  describe('findOrCreateUser', () => {
+    const platformId = 'aac7d4b1-99d5-481e-a765-93f4caf87df2';
+    const uuid = 'f069ab0b-2c99-4914-804d-d0d10fb4a7c4';
+    const external_id = `${platformId}/${uuid}`;
+    const is_test = true;
+
+    const findOrCreateUserRequest = { external_id, is_test, sso: 'true' };
+    const findOrCreateUserResponse = { id: 123, uuid, is_test, sso: 'SomeToken' };
+
+    it('finds or creates a user in OpenStax Accounts and returns their SSO token and info', async() => {
+      fetchSpy.mockReturnValueOnce(Promise.resolve({json: async() => findOrCreateUserResponse, status: 201}));
+      expect(await accounts.findOrCreateUser(findOrCreateUserRequest)).toEqual(findOrCreateUserResponse);
+      expect(fetchSpy.mock.calls).toMatchInlineSnapshot(`
+[
+  [
+    "accountsBaseString/api/user/find-or-create",
+    {
+      "body": "{"external_id":"aac7d4b1-99d5-481e-a765-93f4caf87df2/f069ab0b-2c99-4914-804d-d0d10fb4a7c4","is_test":true,"sso":"true"}",
+      "headers": {
+        "Authorization": "Bearer accountsAuthTokenString",
+      },
+      "method": "POST",
+    },
+  ],
+]
+`);
+    });
+
+    it('throws an error if Accounts returns an unexpected status code', async() => {
+      fetchSpy.mockReturnValueOnce(Promise.resolve({json: async() => ({}), status: 409}));
+      await expect(accounts.findOrCreateUser(findOrCreateUserRequest)).rejects.toThrow(
+        'Received unexpected status code 409 for Accounts API call: POST accountsBaseString/api/user/find-or-create'
+      );
+    });
+  });
+
+  describe('getUser', () => {
+    const user = {
+      id: 123,
+      uuid: 'f069ab0b-2c99-4914-804d-d0d10fb4a7c4',
+      is_test: true,
+      first_name: 'Som',
+      last_name: 'User',
+      full_name: 'Som E. User',
+      title: 'The Honorable',
+      suffix: 'Junior',
+      is_not_gdpr_location: true,
+      renewal_eligible: false,
+      opt_out_of_cookies: true,
+      using_openstax: false,
+      salesforce_contact_id: 'abc123',
+      faculty_status: 'confirmed_faculty',
+      role: 'librarian',
+      self_reported_school: 'Test U',
+      school_name: 'Test University',
+      school_location: 'Earth, Texas',
+      is_kip: true,
+      is_admin: true,
+      grant_tutor_access: true,
+      contact_infos: [],
+      applications: []
+    };
+
+    it('returns a user\'s info when given their SSO token', async() => {
+      fetchSpy.mockReturnValueOnce(Promise.resolve({json: async() => user, status: 200}));
+      expect(await accounts.getUser('ValidToken')).toEqual(user);
+      expect(fetchSpy.mock.calls).toMatchInlineSnapshot(`
+[
+  [
+    "accountsBaseString/api/user",
+    {
+      "headers": {
+        "Authorization": "Bearer ValidToken",
+      },
+      "method": "GET",
+    },
+  ],
+]
+`);
+    });
+
+    it('throws an error if Accounts returns an unexpected status code', async() => {
+      fetchSpy.mockReturnValueOnce(Promise.resolve({json: async() => ({}), status: 403}));
+      await expect(accounts.getUser('InvalidToken')).rejects.toThrow(
+        'Received unexpected status code 403 for Accounts API call: GET accountsBaseString/api/user'
+      );
+    });
+  });
+
+  describe('linkUser', () => {
+    const userId = 123;
+    const externalId = 'SomePlatform/SomeId';
+    const validRequestAndResponse = { externalId, userId };
+
+    it('links a userId with the given externalId', async() => {
+      fetchSpy.mockReturnValueOnce(Promise.resolve({json: async() => validRequestAndResponse, status: 200}));
+      expect(await accounts.linkUser(validRequestAndResponse)).toEqual(validRequestAndResponse);
+      expect(fetchSpy.mock.calls).toMatchInlineSnapshot(`
+[
+  [
+    "accountsBaseString/api/user/external-ids",
+    {
+      "body": "{"external_id":"SomePlatform/SomeId","user_id":123}",
+      "headers": {
+        "Authorization": "Bearer accountsAuthTokenString",
+      },
+      "method": "POST",
+    },
+  ],
+]
+`);
+    });
+
+    it('throws an error if Accounts returns an unexpected status code', async() => {
+      fetchSpy.mockReturnValueOnce(Promise.resolve({json: async() => ({}), status: 403}));
+      await expect(accounts.linkUser(validRequestAndResponse)).rejects.toThrow(
+        'Received unexpected status code 403 for Accounts API call: POST accountsBaseString/api/user/external-ids'
+      );
+    });
+  });
+
+  describe('mapUserUuids', () => {
+    const platformId = 'aac7d4b1-99d5-481e-a765-93f4caf87df2';
+    const platformUserId1 = 'f069ab0b-2c99-4914-804d-d0d10fb4a7c4';
+    const platformUserId2 = '4a1d4631-20b7-4caf-8e0d-ccca13fed2ed';
+    const uuid1 = '3f5d0860-e573-4c45-8d56-10a32cfe70e1';
+    const uuid2 = '52b22b6d-1986-42e6-9ab5-9da59f2fb1ec';
+    const external_id1 = `${platformId}/${platformUserId1}`;
+    const external_id2 = `${platformId}/${platformUserId2}`;
+    const full_name1 = 'Alice';
+    const full_name2 = 'Bob';
+    const is_test = true;
+
+    let items: any;
+
+    let searchUsersResponse: any;
+
+    let userUuidsMap: { [uuid: string]: string };
+
+    beforeEach(() => {
+      items = [
+        { id: 123, uuid: uuid1, external_ids: [ external_id1 ], full_name: full_name1, is_test },
+        { id: 456, uuid: uuid2, external_ids: [ external_id2 ], full_name: full_name2, is_test },
+      ];
+      searchUsersResponse = { items, total_count: items.length };
+      userUuidsMap = {
+        [uuid1]: 'foo',
+        [uuid2]: 'bar',
+      };
+      fetchSpy.mockReturnValueOnce(Promise.resolve({json: async() => searchUsersResponse, status: 200}));
+    });
+
+    it('rekeys a map of user uuids to some object to an array of objects containing the platform user ids', async () => {
+      const mappedResult = await accounts.mapUserUuids(userUuidsMap, platformId);
+
+      expect(mappedResult[0].data).toEqual(userUuidsMap[uuid1]);
+      expect(mappedResult[0].fullName).toEqual(full_name1);
+      expect(mappedResult[0].uuid).toEqual(uuid1);
+      expect(mappedResult[0].platformUserId).toEqual(platformUserId1);
+      expect(mappedResult[1].data).toEqual(userUuidsMap[uuid2]);
+      expect(mappedResult[1].fullName).toEqual(full_name2);
+      expect(mappedResult[1].uuid).toEqual(uuid2);
+      expect(mappedResult[1].platformUserId).toEqual(platformUserId2);
+      expect(mappedResult).toHaveLength(2);
+
+      expect(mockLogEvent).not.toHaveBeenCalled();
+    });
+
+    it('logs a warning if Accounts search doesn\'t return one of the users', async () => {
+      const uuid3 = uuid();
+      userUuidsMap[uuid3] = 'baz';
+
+      const mappedResult = await accounts.mapUserUuids(userUuidsMap, platformId);
+
+      expect(mappedResult[0].data).toEqual(userUuidsMap[uuid1]);
+      expect(mappedResult[0].fullName).toEqual(full_name1);
+      expect(mappedResult[0].uuid).toEqual(uuid1);
+      expect(mappedResult[0].platformUserId).toEqual(platformUserId1);
+      expect(mappedResult[1].data).toEqual(userUuidsMap[uuid2]);
+      expect(mappedResult[1].fullName).toEqual(full_name2);
+      expect(mappedResult[1].uuid).toEqual(uuid2);
+      expect(mappedResult[1].platformUserId).toEqual(platformUserId2);
+      expect(mappedResult).toHaveLength(2);
+
+      expect(mockLogEvent).toHaveBeenCalledWith(Level.Warn, {
+        accountsUuids: [uuid1, uuid2].sort(),
+        message: 'Unexpected Accounts user search results',
+        uuids: [uuid1, uuid2, uuid3].sort(),
+      });
+    });
+
+    it('logs a warning if the Accounts user is missing an external_id matching the idToken\'s platformId', async () => {
+      const platformId = uuid();
+      const mappedResult = await accounts.mapUserUuids(userUuidsMap, platformId);
+
+      expect(mappedResult[0].data).toEqual(userUuidsMap[uuid1]);
+      expect(mappedResult[0].fullName).toEqual(full_name1);
+      expect(mappedResult[0].uuid).toEqual(uuid1);
+      expect(mappedResult[0].platformUserId).toBeUndefined();
+      expect(mappedResult[1].data).toEqual(userUuidsMap[uuid2]);
+      expect(mappedResult[1].fullName).toEqual(full_name2);
+      expect(mappedResult[1].uuid).toEqual(uuid2);
+      expect(mappedResult[1].platformUserId).toBeUndefined();
+      expect(mappedResult).toHaveLength(2);
+
+      expect(mockLogEvent).toHaveBeenNthCalledWith(1, Level.Warn, {
+        accountsUuid: uuid1,
+        message: 'Accounts user has no external_id matching the given platformId',
+        platformId,
+      });
+
+      expect(mockLogEvent).toHaveBeenNthCalledWith(2, Level.Warn, {
+        accountsUuid: uuid2,
+        message: 'Accounts user has no external_id matching the given platformId',
+        platformId,
+      });
+    });
+
+    it('rekeys a map of user uuids to some object to an array of objects containing the user full_names', async () => {
+      const mappedResult = await accounts.mapUserUuids(userUuidsMap);
+
+      expect(mappedResult[0].data).toEqual(userUuidsMap[uuid1]);
+      expect(mappedResult[0].fullName).toEqual(full_name1);
+      expect(mappedResult[0].uuid).toEqual(uuid1);
+      expect(mappedResult[0].platformUserId).toBeUndefined();
+      expect(mappedResult[1].data).toEqual(userUuidsMap[uuid2]);
+      expect(mappedResult[1].fullName).toEqual(full_name2);
+      expect(mappedResult[1].uuid).toEqual(uuid2);
+      expect(mappedResult[1].platformUserId).toBeUndefined();
+      expect(mappedResult).toHaveLength(2);
+
+      expect(mockLogEvent).not.toHaveBeenCalled();
+    });
+
+    it('logs a warning if the Accounts user is missing a full_name', async () => {
+      items.forEach((item: { full_name: string }) => item.full_name = '');
+
+      const mappedResult = await accounts.mapUserUuids(userUuidsMap);
+
+      expect(mappedResult[0].data).toEqual(userUuidsMap[uuid1]);
+      expect(mappedResult[0].fullName).toBe('');
+      expect(mappedResult[0].uuid).toEqual(uuid1);
+      expect(mappedResult[0].platformUserId).toBeUndefined();
+      expect(mappedResult[1].data).toEqual(userUuidsMap[uuid2]);
+      expect(mappedResult[1].fullName).toBe('');
+      expect(mappedResult[1].uuid).toEqual(uuid2);
+      expect(mappedResult[1].platformUserId).toBeUndefined();
+      expect(mappedResult).toHaveLength(2);
+
+      expect(mockLogEvent).toHaveBeenNthCalledWith(1, Level.Warn, {
+        accountsUuid: uuid1,
+        message: 'Accounts user has no full_name',
+      });
+
+      expect(mockLogEvent).toHaveBeenNthCalledWith(2, Level.Warn, {
+        accountsUuid: uuid2,
+        message: 'Accounts user has no full_name',
+      });
+    });
+  });
+
+  describe('mapUserData', () => {
+    const uuid1 = '3f5d0860-e573-4c45-8d56-10a32cfe70e1';
+    const uuid2 = '52b22b6d-1986-42e6-9ab5-9da59f2fb1ec';
+    const full_name1 = 'Alice';
+    const full_name2 = 'Bob';
+    const is_test = true;
+    let items: any;
+    let searchUsersResponse: any;
+
+    beforeEach(() => {
+      items = [
+        { id: 123, uuid: uuid1, full_name: full_name1, is_test },
+        { id: 456, uuid: uuid2, full_name: full_name2, is_test },
+      ];
+      searchUsersResponse = { items, total_count: items.length };
+      fetchSpy.mockReturnValueOnce(Promise.resolve({json: async() => searchUsersResponse, status: 200}));
+    });
+
+    it('works with empty array', async () => {
+      const input: any[] = [];
+
+      const result = await accounts.mapUserData(input, item => item.userUuid, (user, item) => ({
+        ...item,
+        user: user ? {
+          fullName: user.full_name,
+          uuid: user.uuid,
+        } : undefined
+      }));
+
+      expect(fetchSpy).not.toHaveBeenCalled();
+      expect(result).toEqual([]);
+    });
+
+    it('adds single user data to an array of objects', async () => {
+      const input = [{ userUuid: uuid1 }, { userUuid: uuid2 }];
+
+      const result = await accounts.mapUserData(input, item => item.userUuid, (user, item) => ({
+        ...item,
+        user: user ? {
+          fullName: user.full_name,
+          uuid: user.uuid,
+        } : undefined
+      }));
+
+      expect(result).toEqual([
+        { userUuid: uuid1, user: {fullName: 'Alice', uuid: uuid1} },
+        { userUuid: uuid2, user: {fullName: 'Bob', uuid: uuid2} },
+      ]);
+    });
+
+    it('adds multiple user data to an array of objects', async () => {
+      const input = [{ userUuids: [uuid1, uuid2] }, { userUuids: [uuid2] }];
+
+      const result = await accounts.mapUsersData(input, item => item.userUuids, (users, item) => ({
+        ...item,
+        users: item.userUuids.map(uuid => ({
+          fullName: users.get(uuid)?.full_name ?? 'unknown user',
+          uuid: uuid,
+        }))
+      }));
+
+      expect(result).toEqual([
+        { userUuids: [uuid1, uuid2], users: [{fullName: 'Alice', uuid: uuid1},{fullName: 'Bob', uuid: uuid2}] },
+        { userUuids: [uuid2], users: [{fullName: 'Bob', uuid: uuid2}] },
+      ]);
+    });
+  });
+
+  describe('searchUsers', () => {
+    const platformId = 'aac7d4b1-99d5-481e-a765-93f4caf87df2';
+    const platformUserId1 = 'f069ab0b-2c99-4914-804d-d0d10fb4a7c4';
+    const platformUserId2 = '4a1d4631-20b7-4caf-8e0d-ccca13fed2ed';
+    const uuid1 = '3f5d0860-e573-4c45-8d56-10a32cfe70e1';
+    const uuid2 = '52b22b6d-1986-42e6-9ab5-9da59f2fb1ec';
+    const external_id1 = `${platformId}/${platformUserId1}`;
+    const external_id2 = `${platformId}/${platformUserId2}`;
+    const is_test = true;
+
+    const items = [
+      { id: 123, uuid: uuid1, external_ids: [ external_id1 ], is_test },
+      { id: 456, uuid: uuid2, external_ids: [ external_id2 ], is_test },
+    ];
+
+    const searchUsersRequest = { q: items.map((user) => `uuid:${user.uuid}`).join(' ') };
+    const searchUsersResponse = { items, total_count: items.length };
+
+    it('searches users in OpenStax Accounts by uuid and returns their external_ids', async() => {
+      fetchSpy.mockReturnValueOnce(Promise.resolve({json: async() => searchUsersResponse, status: 200}));
+      expect(await accounts.searchUsers(searchUsersRequest)).toEqual(searchUsersResponse);
+      expect(fetchSpy.mock.calls).toMatchInlineSnapshot(`
+[
+  [
+    "accountsBaseString/api/users?q=uuid%3A3f5d0860-e573-4c45-8d56-10a32cfe70e1%20uuid%3A52b22b6d-1986-42e6-9ab5-9da59f2fb1ec",
+    {
+      "headers": {
+        "Authorization": "Bearer accountsAuthTokenString",
+      },
+      "method": "GET",
+    },
+  ],
+]
+`);
+    });
+
+    it('throws an error if Accounts returns an unexpected status code', async() => {
+      fetchSpy.mockReturnValueOnce(Promise.resolve({json: async() => ({}), status: 404}));
+      await expect(accounts.searchUsers(searchUsersRequest)).rejects.toThrow(
+        'Received unexpected status code 404 for Accounts API call: GET accountsBaseString/api/users'
+      );
+    });
+  });
+
+  describe('updateUser', () => {
+    const body = {
+      consent_preferences: {
+        accepted: ['test'],
+        rejected: ['nothing'],
+      },
+    };
+    const user = {
+      id: 123,
+      consent_preferences: {
+        accepted: ['test'],
+        rejected: ['nothing'],
+      },
+    };
+
+    it('updates and returns the user', async() => {
+      fetchSpy.mockReturnValueOnce(Promise.resolve({json: async() => user, status: 200}));
+      expect(await accounts.updateUser('ValidToken', body)).toEqual(user);
+      expect(fetchSpy.mock.calls).toMatchInlineSnapshot(`
+[
+  [
+    "accountsBaseString/api/user",
+    {
+      "body": "{"consent_preferences":{"accepted":["test"],"rejected":["nothing"]}}",
+      "headers": {
+        "Authorization": "Bearer ValidToken",
+      },
+      "method": "PUT",
+    },
+  ],
+]
+`);
+    });
+
+    it('throws an error if Accounts returns an unexpected status code', async() => {
+      fetchSpy.mockReturnValueOnce(Promise.resolve({json: async() => ({}), status: 403}));
+      await expect(accounts.updateUser('InvalidToken', body)).rejects.toThrow(
+        'Received unexpected status code 403 for Accounts API call: PUT accountsBaseString/api/user'
+      );
+    });
+  });
+});