@w3-commons/js-build-resources 0.0.1-security → 1.0.4

package/settings-service/src/__tests__/unit/repo/settingsRepo.spec.ts

@@ -0,0 +1,614 @@
+import { AppSettingsResponse } from 'types/settingsRepoTypes';
+import { ProfileResponse } from 'types/unifiedProfileTypes';
+import { SettingsRepoFactory } from '../../../repo/settingsRepoFactory';
+import { cassandraDBHelpers } from '../../../repo/cassandraDBHelpers';
+import { SettingsRepo } from '../../../repo/settingsRepo';
+import * as UP from '../../../unified-profile/unifiedProfileUtils';
+import { INVALID_APP_ID, TEST_APP_ID, TEST_USER_ID } from '../../utils/test-utils';
+
+jest.mock('../../../unified-profile/unifiedProfileUtils');
+
+let settingsRepo: SettingsRepo;
+
+beforeAll(() => {
+  settingsRepo = SettingsRepoFactory.accessOrCreateSingleton();
+});
+
+const USER_ID = 'AAABBBCCC';
+const INVALID_USER_ID = 'BBBCCCDDD';
+const APP_ID = 'test';
+const SETTING_NAME = 'theme';
+const SETTING_VALUE = 'dark';
+const SETTING_OPTIONS = ['true', 'false'];
+const SETTING_DEFAULT = 'false';
+
+export const languageAppSettings = {
+  secondaryLanguages: {
+    options: ['en', 'fr', 'sk'],
+    setting_type: 'array',
+    default: null,
+    deprecated_values: null,
+  },
+  primaryLanguage: {
+    options: ['en', 'fr', 'sk'],
+    setting_type: 'string',
+    default: 'en',
+    deprecated_values: null,
+  },
+};
+
+describe('get settings using userID and appID', () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+  it('should return empty set while fetching invalid user_id (no app data)', async () => {
+    const mockResultSet: any = {
+      rows: [],
+    };
+    const appSettingsSpy = jest.spyOn(settingsRepo, 'getAppSettings').mockResolvedValueOnce({});
+    cassandraDBHelpers.execute = jest.fn().mockResolvedValueOnce(mockResultSet);
+    expect(await settingsRepo.getUserSettings(INVALID_USER_ID, APP_ID)).toEqual({});
+    expect(appSettingsSpy).toHaveBeenCalled();
+  });
+
+  it('should return settings when using valid user_id', async () => {
+    const dbRecords = [
+      { user_id: USER_ID, app_id: APP_ID, setting_name: SETTING_NAME, setting_value: SETTING_VALUE },
+    ];
+    const mockResultSet: any = {
+      rows: dbRecords,
+    };
+    const mockEmptyResultSet: any = {
+      rows: [],
+    };
+    cassandraDBHelpers.execute = jest.fn().mockReturnValueOnce(
+      new Promise((resolve) => {
+        resolve(mockResultSet);
+      }),
+    );
+    const mockValue = {};
+    mockValue[SETTING_NAME] = { default: SETTING_DEFAULT, options: [SETTING_VALUE] };
+    const appSettingsSpy = jest
+      .spyOn(settingsRepo, 'getAppSettings')
+      .mockResolvedValueOnce(mockValue)
+      .mockResolvedValueOnce(mockValue);
+    let usersSettings = await settingsRepo.getUserSettings(USER_ID, APP_ID);
+    expect(usersSettings).toBeDefined();
+    expect(usersSettings[SETTING_NAME]).toEqual(SETTING_VALUE);
+    expect(appSettingsSpy).toHaveBeenCalledTimes(1);
+
+    cassandraDBHelpers.execute = jest.fn().mockReturnValueOnce(
+      new Promise((resolve) => {
+        resolve(mockEmptyResultSet);
+      }),
+    );
+    jest.clearAllMocks();
+    usersSettings = await settingsRepo.getUserSettings(USER_ID, APP_ID);
+    expect(usersSettings).toBeDefined();
+    expect(usersSettings[SETTING_NAME]).toEqual(SETTING_DEFAULT);
+    expect(appSettingsSpy).toHaveBeenCalledTimes(1);
+  });
+  it('should not return settings where name is null', async () => {
+    const dbRecords = [
+      { user_id: USER_ID, app_id: APP_ID, setting_name: null, setting_value: SETTING_VALUE },
+    ];
+    const mockResultSet: any = {
+      rows: dbRecords,
+    };
+    const appSettingsSpy = jest.spyOn(settingsRepo, 'getAppSettings').mockResolvedValueOnce({});
+    cassandraDBHelpers.execute = jest.fn().mockReturnValueOnce(
+      new Promise((resolve) => {
+        resolve(mockResultSet);
+      }),
+    );
+    const usersSettings = await settingsRepo.getUserSettings(USER_ID, APP_ID);
+    expect(usersSettings).toBeDefined();
+    expect(usersSettings).toEqual({});
+    expect(appSettingsSpy).toHaveBeenCalledTimes(1);
+  });
+  it('should throw an error if the database errors out', async () => {
+    const appSettingsSpy = jest.spyOn(settingsRepo, 'getAppSettings').mockResolvedValueOnce({});
+    cassandraDBHelpers.execute = jest.fn().mockReturnValueOnce(Promise.reject(new Error('database error')));
+    expect(settingsRepo.getUserSettings(INVALID_USER_ID, APP_ID)).rejects.toEqual(
+      Error(`Error while reading getUserSettings`),
+    );
+    expect(appSettingsSpy).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('update settings using userID and appID', () => {
+  it('should return true if call works', async () => {
+    const mockResultSet: any = {
+      rows: [{ user_id: USER_ID, app_id: APP_ID, setting_name: SETTING_NAME, setting_value: SETTING_VALUE }],
+    };
+    cassandraDBHelpers.batch = jest.fn().mockReturnValueOnce(
+      new Promise((resolve) => {
+        resolve(mockResultSet);
+      }),
+    );
+    const response = await settingsRepo.updateUserSettings(USER_ID, APP_ID, SETTING_NAME, SETTING_VALUE);
+    expect(response).toBeDefined();
+    expect(response).toEqual(true);
+  });
+  it('should throw an error if the database errors out', async () => {
+    cassandraDBHelpers.batch = jest.fn().mockImplementationOnce(() => {
+      throw new Error('error from db');
+    });
+    expect(
+      settingsRepo.updateUserSettings(INVALID_USER_ID, APP_ID, SETTING_NAME, SETTING_VALUE),
+    ).rejects.toEqual(Error(`error from db`));
+  });
+});
+
+describe('delete settings using userID', () => {
+  const mockResultSet: any = {
+    rows: [{ user_id: USER_ID, app_id: APP_ID, setting_name: null, setting_value: SETTING_VALUE }],
+  };
+  it('should return true', async () => {
+    cassandraDBHelpers.execute = jest.fn().mockResolvedValueOnce(mockResultSet);
+    cassandraDBHelpers.batch = jest.fn().mockReturnValueOnce(
+      new Promise((resolve) => {
+        resolve(mockResultSet);
+      }),
+    );
+    const response = await settingsRepo.deleteUserSettings(USER_ID);
+    expect(response).toBeDefined();
+    expect(response).toEqual(true);
+  });
+  it('should throw an error if the database errors out', async () => {
+    cassandraDBHelpers.execute = jest.fn().mockResolvedValueOnce(mockResultSet);
+    cassandraDBHelpers.batch = jest.fn().mockImplementationOnce(() => {
+      throw new Error('database error');
+    });
+    expect(settingsRepo.deleteUserSettings(INVALID_USER_ID)).rejects.toEqual(Error('database error'));
+  });
+});
+
+describe('get app settings', () => {
+  it('should return empty object while fetching new app_id', async () => {
+    const mockResultSet: any = {
+      rows: [],
+    };
+
+    cassandraDBHelpers.execute = jest
+      .fn()
+      .mockResolvedValueOnce(mockResultSet)
+      .mockResolvedValueOnce(mockResultSet);
+    // expect(await settingsRepo.getAppSettings(INVALID_APP_ID, undefined)).toEqual({});
+
+    expect(await settingsRepo.getAppSettings(INVALID_APP_ID, SETTING_NAME)).toEqual({});
+  });
+
+  it('should return settings for valid app_id', async () => {
+    const dbRecords = [
+      {
+        app_id: APP_ID,
+        setting_name: SETTING_NAME,
+        setting_default: SETTING_DEFAULT,
+        setting_options: SETTING_OPTIONS,
+        setting_type: 'string',
+      },
+      {
+        app_id: APP_ID,
+        setting_name: null,
+        setting_options: SETTING_OPTIONS,
+        setting_type: null,
+      },
+    ];
+    const mockResultSet: any = {
+      rows: dbRecords,
+    };
+
+    cassandraDBHelpers.execute = jest
+      .fn()
+      .mockResolvedValueOnce(mockResultSet)
+      .mockResolvedValueOnce(mockResultSet);
+
+    let appSettings = await settingsRepo.getAppSettings(APP_ID, undefined);
+    expect(appSettings).toBeDefined();
+    expect(appSettings[SETTING_NAME]).toEqual({
+      default: SETTING_DEFAULT,
+      options: SETTING_OPTIONS,
+      setting_type: 'string',
+    });
+
+    appSettings = await settingsRepo.getAppSettings(APP_ID, SETTING_NAME);
+    expect(appSettings).toBeDefined();
+    expect(appSettings[SETTING_NAME]).toEqual({
+      default: SETTING_DEFAULT,
+      options: SETTING_OPTIONS,
+      setting_type: 'string',
+    });
+  });
+
+  it('should return deprecated_values for valid app_id with deprecated_values object', async () => {
+    const dbRecords = [
+      {
+        app_id: APP_ID,
+        setting_name: SETTING_NAME,
+        setting_default: SETTING_DEFAULT,
+        setting_options: SETTING_OPTIONS,
+        setting_type: 'string',
+        deprecated_values: '{ "oldValue": "newValue"}',
+      },
+      {
+        app_id: APP_ID,
+        setting_name: null,
+        setting_options: SETTING_OPTIONS,
+        setting_type: null,
+      },
+    ];
+    const mockResultSet: any = {
+      rows: dbRecords,
+    };
+    cassandraDBHelpers.execute = jest.fn().mockResolvedValueOnce(mockResultSet);
+
+    const appSettings = await settingsRepo.getAppSettings(APP_ID, undefined);
+    expect(appSettings).toBeDefined();
+    expect(appSettings[SETTING_NAME].deprecated_values).toEqual({ oldValue: 'newValue' });
+  });
+
+  it('should not return deprecated_values for valid app_id with no deprecated values', async () => {
+    const dbRecords = [
+      {
+        app_id: APP_ID,
+        setting_name: SETTING_NAME,
+        setting_default: SETTING_DEFAULT,
+        setting_options: SETTING_OPTIONS,
+        setting_type: 'string',
+      },
+      {
+        app_id: APP_ID,
+        setting_name: null,
+        setting_options: SETTING_OPTIONS,
+        setting_type: null,
+      },
+    ];
+    const mockResultSet: any = {
+      rows: dbRecords,
+    };
+    cassandraDBHelpers.execute = jest.fn().mockReturnValueOnce(
+      new Promise((resolve) => {
+        resolve(mockResultSet);
+      }),
+    );
+
+    const appSettings = await settingsRepo.getAppSettings(APP_ID, undefined);
+    expect(appSettings[SETTING_NAME].deprecated_values).toBeUndefined();
+  });
+
+  it('should throw an error if the database errors out', async () => {
+    cassandraDBHelpers.execute = jest.fn().mockReturnValueOnce(Promise.reject(new Error('database error')));
+    expect(settingsRepo.getAppSettings(APP_ID, SETTING_NAME)).rejects.toEqual(
+      Error(`Error while reading getAppSettings`),
+    );
+  });
+});
+
+describe('update app settings', () => {
+  it('should return true if call works', async () => {
+    const mockResultSet: any = {
+      rows: [],
+    };
+
+    cassandraDBHelpers.execute = jest
+      .fn()
+      .mockResolvedValueOnce(mockResultSet)
+      .mockResolvedValueOnce(mockResultSet);
+    let response = await settingsRepo.updateAppSettings({
+      appId: APP_ID,
+      settingName: SETTING_NAME,
+      settingOptions: SETTING_OPTIONS,
+    });
+    expect(response).toBeDefined();
+    expect(response).toEqual(true);
+    response = await settingsRepo.updateAppSettings({
+      appId: APP_ID,
+      settingName: SETTING_NAME,
+      settingDefault: SETTING_DEFAULT,
+      settingOptions: SETTING_OPTIONS,
+    });
+    expect(response).toBeDefined();
+    expect(response).toEqual(true);
+  });
+
+  it('should return true if call works and has deprecated_values', async () => {
+    const mockResultSet: any = {
+      rows: [],
+    };
+    cassandraDBHelpers.execute = jest
+      .fn()
+      .mockResolvedValueOnce(mockResultSet)
+      .mockResolvedValueOnce(mockResultSet);
+    let response = await settingsRepo.updateAppSettings({
+      appId: APP_ID,
+      settingName: SETTING_NAME,
+      settingOptions: SETTING_OPTIONS,
+      deprecatedValues: '{ "oldValue": "newValue"}',
+    });
+    expect(response).toBeDefined();
+    expect(response).toEqual(true);
+    response = await settingsRepo.updateAppSettings({
+      appId: APP_ID,
+      settingName: SETTING_NAME,
+      settingDefault: SETTING_DEFAULT,
+      settingOptions: SETTING_OPTIONS,
+    });
+    expect(response).toBeDefined();
+    expect(response).toEqual(true);
+  });
+
+  it('should throw an error if the database errors out', async () => {
+    cassandraDBHelpers.execute = jest.fn().mockReturnValueOnce(Promise.reject(new Error('database error')));
+    expect(
+      settingsRepo.updateAppSettings({
+        appId: APP_ID,
+        settingName: 'null',
+        settingOptions: SETTING_OPTIONS,
+      }),
+    ).rejects.toEqual(Error(`Error while updating AppSettings`));
+  });
+});
+
+describe('delete app settings', () => {
+  it('should return true', async () => {
+    const mockResultSet: any = {
+      rows: [],
+    };
+
+    cassandraDBHelpers.execute = jest.fn().mockReturnValueOnce(
+      new Promise((resolve) => {
+        resolve(mockResultSet);
+      }),
+    );
+    const response = await settingsRepo.deleteAppSettings(APP_ID, SETTING_NAME);
+    expect(response).toBeDefined();
+    expect(response).toEqual(true);
+  });
+  it('should throw an error if the database errors out', async () => {
+    cassandraDBHelpers.execute = jest.fn().mockReturnValueOnce(Promise.reject(new Error('database error')));
+    expect(settingsRepo.deleteAppSettings(APP_ID, '')).rejects.toEqual(
+      Error(`Error while deleting AppSettings`),
+    );
+  });
+});
+
+describe('checkValueIsValidOption', () => {
+  const optionsArray = ['en', 'sk'];
+
+  it('returns true with valid array of inputs', () => {
+    const updatedValue = ['en', 'sk'];
+    expect(settingsRepo.checkValueIsValidOption(updatedValue, optionsArray)).toBeTruthy();
+  });
+
+  it('returns true with valid input string', () => {
+    const updatedValue = 'sk';
+
+    expect(settingsRepo.checkValueIsValidOption([updatedValue], optionsArray)).toBeTruthy();
+  });
+
+  it('returns false with array containing invalid value', () => {
+    const updatedValue = ['br', 'en'];
+
+    expect(settingsRepo.checkValueIsValidOption(updatedValue, optionsArray)).toBeFalsy();
+  });
+
+  it('returns false with invalid string value', () => {
+    const updatedValue = 'br';
+
+    expect(settingsRepo.checkValueIsValidOption([updatedValue], optionsArray));
+  });
+});
+
+describe('getUserSettings array value tests', () => {
+  const mockValue: AppSettingsResponse = {};
+  mockValue.secondaryLanguages = {
+    default: '',
+    options: ['en', 'sk', 'fr'],
+    setting_type: 'array',
+    deprecated_values: null,
+  };
+
+  it('can retrieve a value and return it as array', async () => {
+    const dbRecords = [
+      { user_id: USER_ID, app_id: APP_ID, setting_name: 'secondaryLanguages', setting_value: 'sk,en,fr' },
+    ];
+    const mockResultSet: any = {
+      rows: dbRecords,
+    };
+    settingsRepo.getAppSettings = jest.fn().mockReturnValueOnce(mockValue);
+    cassandraDBHelpers.execute = jest.fn().mockReturnValueOnce(
+      new Promise((resolve) => {
+        resolve(mockResultSet);
+      }),
+    );
+
+    const userSettings = await settingsRepo.getUserSettings(USER_ID, APP_ID);
+
+    expect(userSettings.secondaryLanguages).toEqual(['sk', 'en', 'fr']);
+  });
+
+  it('will return default value if one value of array is not a valid option', async () => {
+    const dbRecords = [
+      { user_id: USER_ID, app_id: APP_ID, setting_name: 'secondaryLanguages', setting_value: 'br,en,fr' },
+    ];
+    const mockResultSet: any = {
+      rows: dbRecords,
+    };
+    settingsRepo.getAppSettings = jest.fn().mockReturnValueOnce(mockValue);
+    cassandraDBHelpers.execute = jest.fn().mockReturnValueOnce(
+      new Promise((resolve) => {
+        resolve(mockResultSet);
+      }),
+    );
+    const userSettings = await settingsRepo.getUserSettings(USER_ID, APP_ID);
+    expect(userSettings.secondaryLanguages).toStrictEqual([]);
+  });
+});
+
+describe('fetchAndMapUserSettings secondaryLanguages tests', () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('calls UP when there is no secondaryLanguages value stored in the db', async () => {
+    const settingsDBRows = [
+      {
+        user_id: USER_ID,
+        app_id: 'general',
+        setting_name: 'primaryLanguage',
+        setting_value: 'fr',
+      },
+    ];
+    const getUnifiedProfileSpy = jest.spyOn(UP, 'getUnifiedProfile').mockResolvedValueOnce({
+      content: {
+        languages: ['French (Belgium)', 'English'],
+      },
+    } as ProfileResponse);
+
+    jest.spyOn(settingsRepo, 'updateUserSettings').mockResolvedValueOnce(true);
+    const result = await settingsRepo.fetchAndMapLanguageValues({
+      userId: USER_ID,
+      appId: 'general',
+      result: { primaryLanguage: 'fr' },
+      filter: languageAppSettings,
+      settingsDBRows,
+    });
+
+    expect(getUnifiedProfileSpy).toHaveBeenCalledTimes(1);
+    expect(result).toMatchObject({ secondaryLanguages: ['en'] });
+  });
+  it('stores retrieved UP secondaryLanguages values in db', async () => {
+    const settingsDBRows = [
+      {
+        user_id: USER_ID,
+        app_id: 'general',
+        setting_name: 'primaryLanguage',
+        setting_value: 'fr',
+      },
+    ];
+    const getUnifiedProfileSpy = jest.spyOn(UP, 'getUnifiedProfile').mockResolvedValueOnce({
+      content: {
+        languages: ['French (Belgium)', 'English'],
+      },
+    } as ProfileResponse);
+
+    const updateSpy = jest.spyOn(settingsRepo, 'updateUserSettings').mockResolvedValueOnce(true);
+    await settingsRepo.fetchAndMapLanguageValues({
+      userId: USER_ID,
+      appId: 'general',
+      result: { primaryLanguage: 'fr' },
+      filter: languageAppSettings,
+      settingsDBRows,
+    });
+
+    expect(updateSpy).toHaveBeenCalledTimes(1);
+    expect(updateSpy).toHaveBeenCalledWith(USER_ID, 'general', 'secondaryLanguages', 'en');
+    expect(getUnifiedProfileSpy).toHaveBeenCalled();
+  });
+  it('stores empty string when no secondary languages retrieved from UP', async () => {
+    const settingsDBRows = [
+      {
+        user_id: USER_ID,
+        app_id: 'general',
+        setting_name: 'primaryLanguage',
+        setting_value: 'fr',
+      },
+    ];
+    jest.spyOn(UP, 'getUnifiedProfile').mockResolvedValueOnce({ content: {} } as ProfileResponse);
+
+    const updateSpy = jest.spyOn(settingsRepo, 'updateUserSettings').mockResolvedValueOnce(true);
+    await settingsRepo.fetchAndMapLanguageValues({
+      userId: USER_ID,
+      appId: 'general',
+      result: { primaryLanguage: 'fr' },
+      filter: languageAppSettings,
+      settingsDBRows,
+    });
+
+    expect(updateSpy).toHaveBeenCalledTimes(1);
+    expect(updateSpy).toHaveBeenCalledWith(USER_ID, 'general', 'secondaryLanguages', '');
+  });
+  it('does not set secondaryLanguages if value already exists in result', async () => {
+    const settingsDBRows = [
+      {
+        user_id: USER_ID,
+        app_id: 'general',
+        setting_name: 'secondaryLanguages',
+        setting_value: 'sk,fr',
+      },
+    ];
+    const UPSpy = jest.spyOn(UP, 'getUnifiedProfile');
+
+    const updateSpy = jest.spyOn(settingsRepo, 'updateUserSettings').mockResolvedValueOnce(true);
+    await settingsRepo.fetchAndMapLanguageValues({
+      userId: USER_ID,
+      appId: 'general',
+      result: { secondaryLanguages: 'sk,fr', primaryLanguage: 'en' },
+      filter: languageAppSettings,
+      settingsDBRows,
+    });
+
+    expect(UPSpy).not.toHaveBeenCalled();
+    expect(updateSpy).not.toHaveBeenCalled();
+  });
+});
+
+describe('transormAndUpdateDeprecatedValues', () => {
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+  it('returns new value if value argument was in deprecated list', () => {
+    const returnedValue = settingsRepo.transformAndUpdateDeprecatedValues(
+      { GBS: 'IBM Consulting' },
+      {
+        setting_value: 'GBS',
+        setting_name: 'secondaryBusinessUnits',
+        user_id: TEST_USER_ID,
+        app_id: TEST_APP_ID,
+      },
+    );
+
+    jest.spyOn(settingsRepo, 'updateUserSettings').mockResolvedValueOnce(true);
+
+    expect(returnedValue).toBe('IBM Consulting');
+  });
+
+  it('stores new value to db if old value in deprecated list', () => {
+    settingsRepo.transformAndUpdateDeprecatedValues(
+      { GBS: 'IBM Consulting' },
+      {
+        setting_value: 'GBS',
+        setting_name: 'secondaryBusinessUnits',
+        user_id: TEST_USER_ID,
+        app_id: TEST_APP_ID,
+      },
+    );
+
+    const updateSettingsSpy = jest.spyOn(settingsRepo, 'updateUserSettings').mockResolvedValueOnce(true);
+
+    expect(updateSettingsSpy).toHaveBeenCalledTimes(1);
+    expect(updateSettingsSpy).toHaveBeenCalledWith(
+      TEST_USER_ID,
+      TEST_APP_ID,
+      'secondaryBusinessUnits',
+      'IBM Consulting',
+    );
+  });
+
+  it('returns original value if value not in deprecated list', () => {
+    const returnedValue = settingsRepo.transformAndUpdateDeprecatedValues(
+      { GBS: 'IBM Consulting' },
+      {
+        setting_value: 'F&O',
+        setting_name: 'secondaryBusinessUnits',
+        user_id: TEST_USER_ID,
+        app_id: TEST_APP_ID,
+      },
+    );
+
+    jest.spyOn(settingsRepo, 'updateUserSettings').mockResolvedValueOnce(true);
+
+    expect(returnedValue).toBe('F&O');
+  });
+});

package/settings-service/src/__tests__/unit/unified-profile/UnifiedProfileClient.spec.ts

@@ -0,0 +1,31 @@
+import UnifiedProfileClient from '../../../unified-profile/UnifiedProfileClient';
+import { ProfileResponse } from '../../../types/unifiedProfileTypes';
+
+const TEST_PROFILE: ProfileResponse = {
+  content: { c: 'us', languages: ['en', 'fr'], preferredLanguage: 'English' },
+};
+const UP_CLIENT = new UnifiedProfileClient();
+const TEST_USER_ID = '123456789';
+
+describe('UnifiedProfileClient', () => {
+  it('getProfile should get user profile from Unified Profile', async () => {
+    const getSpy = jest.spyOn(UP_CLIENT.client, 'get').mockResolvedValueOnce({ data: TEST_PROFILE });
+
+    const resp = await UP_CLIENT.getProfile(TEST_USER_ID);
+
+    expect(getSpy).toHaveBeenCalled();
+    expect(resp).toBeDefined();
+    expect(resp?.content.c).toBe('us');
+    expect(resp?.content.languages).toStrictEqual(['en', 'fr']);
+    expect(resp?.content.preferredLanguage).toBe('English');
+  });
+
+  it('should return undefined if Error getting user profile', async () => {
+    const getSpy = jest.spyOn(UP_CLIENT.client, 'get').mockRejectedValueOnce(new Error());
+
+    const resp = await UP_CLIENT.getProfile(TEST_USER_ID);
+
+    expect(getSpy).toHaveBeenCalled();
+    expect(resp).toBeUndefined();
+  });
+});

package/settings-service/src/__tests__/unit/unified-profile/unifiedProfileUtils.spec.ts

@@ -0,0 +1,36 @@
+import UnifiedProfileClient from '../../../unified-profile/UnifiedProfileClient';
+import { ProfileResponse } from '../../../types/unifiedProfileTypes';
+import { getUnifiedProfile } from '../../../unified-profile/unifiedProfileUtils';
+
+const TEST_USER_ID = '123456789';
+const TEST_PROFILE: ProfileResponse = {
+  content: { c: 'us', languages: ['en', 'fr'], preferredLanguage: 'English' },
+};
+
+describe('getUnifiedProfileBackup', () => {
+  it('should call UnifiedProfileClient to get user isoCode', async () => {
+    const upGetSpy = jest
+      .spyOn(UnifiedProfileClient.prototype, 'getProfile')
+      .mockResolvedValueOnce(TEST_PROFILE);
+
+    const resp = await getUnifiedProfile(TEST_USER_ID);
+
+    expect(upGetSpy).toHaveBeenCalled();
+    expect(upGetSpy).toHaveBeenCalledWith(TEST_USER_ID);
+    expect(resp).toBeDefined();
+    expect(resp?.content.c).toBe('us');
+    expect(resp?.content.languages).toStrictEqual(['en', 'fr']);
+    expect(resp?.content.preferredLanguage).toBe('English');
+  });
+
+  it('should return undefined when getProfile returns undefined', async () => {
+    const upGetSpy = jest
+      .spyOn(UnifiedProfileClient.prototype, 'getProfile')
+      .mockResolvedValueOnce(undefined);
+
+    const resp = await getUnifiedProfile(TEST_USER_ID);
+
+    expect(upGetSpy).toHaveBeenCalled();
+    expect(resp).toBeUndefined();
+  });
+});