@openstax/ts-utils 1.34.0 → 1.35.0

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

@@ -1,518 +0,0 @@
-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'
-      );
-    });
-  });
-});