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

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

@@ -0,0 +1,100 @@
+import { SettingsRepoFactory } from '../../../repo/settingsRepoFactory';
+import { cassandraDBHelpers } from '../../../repo/cassandraDBHelpers';
+import * as srq from '../../../repo/settingsRepoQueries';
+import { TEST_APP_ID } from '../../utils/test-utils';
+
+const mockAllUsersRows = [
+  {
+    user_id: 'ABCDEFGHI',
+    app_id: 'general',
+    setting_name: 'primaryLanguage',
+    setting_value: 'en',
+  },
+  {
+    user_id: 'AABBCCDDE',
+    app_id: 'general',
+    setting_name: 'primaryLanguage',
+    setting_value: 'en',
+  },
+  {
+    user_id: 'BBCCDDEEF',
+    app_id: 'general',
+    setting_name: 'primaryLanguage',
+    setting_value: 'en',
+  },
+  {
+    user_id: 'CCDDEEFFG',
+    app_id: 'general',
+    setting_name: 'primaryLanguage',
+    setting_value: 'en',
+  },
+  {
+    user_id: 'DDEEFFGGH',
+    app_id: 'general',
+    setting_name: 'primaryLanguage',
+    setting_value: 'en',
+  },
+];
+
+describe('getAllSettings settingsRepo method', () => {
+  let settingsRepo;
+  beforeAll(() => {
+    settingsRepo = SettingsRepoFactory.accessOrCreateSingleton();
+  });
+  it('should query uses_settings with default values when no query params passed', async () => {
+    const mockResultSet: any = {
+      rows: mockAllUsersRows,
+    };
+    cassandraDBHelpers.paginate = jest.fn().mockResolvedValueOnce(mockResultSet);
+    const response = await settingsRepo.getAllSettings({});
+    expect(response).toBeDefined();
+    expect(response).toMatchObject(mockResultSet);
+    expect(cassandraDBHelpers.paginate).toHaveBeenCalledTimes(1);
+    expect(cassandraDBHelpers.paginate).toHaveBeenCalledWith(srq.allUserSettingsQuery, [], {
+      pageState: '',
+      fetchSize: 500,
+    });
+  });
+  it('should query user_settings_by_app with appId when no settingName passed', async () => {
+    const mockResultSet: any = {
+      rows: mockAllUsersRows,
+    };
+    cassandraDBHelpers.paginate = jest.fn().mockResolvedValueOnce(mockResultSet);
+    const testQueryParams = {
+      pageState: 'test-page-state',
+      settingName: undefined,
+      fetchSize: 10,
+      appId: TEST_APP_ID,
+    };
+    const response = await settingsRepo.getAllSettings(testQueryParams);
+    expect(response).toBeDefined();
+    expect(response).toMatchObject(mockResultSet);
+    expect(cassandraDBHelpers.paginate).toHaveBeenCalledTimes(1);
+    expect(cassandraDBHelpers.paginate).toHaveBeenCalledWith(
+      srq.allUserSettingsByAppIdQuery,
+      [testQueryParams.appId],
+      { pageState: testQueryParams.pageState, fetchSize: testQueryParams.fetchSize },
+    );
+  });
+  it('should query user_settings_by_app with appId and settingName', async () => {
+    const mockResultSet: any = {
+      rows: mockAllUsersRows,
+    };
+    cassandraDBHelpers.paginate = jest.fn().mockResolvedValueOnce(mockResultSet);
+    const testQueryParams = {
+      pageState: 'test-page-state',
+      settingName: 'test-setting-name',
+      fetchSize: 10,
+      appId: TEST_APP_ID,
+    };
+    const response = await settingsRepo.getAllSettings(testQueryParams);
+    expect(response).toBeDefined();
+    expect(response).toMatchObject(mockResultSet);
+    expect(cassandraDBHelpers.paginate).toHaveBeenCalledTimes(1);
+    expect(cassandraDBHelpers.paginate).toHaveBeenCalledWith(
+      srq.allUserSettingsBySettingNameQuery,
+      [testQueryParams.appId, testQueryParams.settingName],
+      { pageState: testQueryParams.pageState, fetchSize: testQueryParams.fetchSize },
+    );
+  });
+});

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

@@ -0,0 +1,249 @@
+import { SettingsRepoFactory } from '../../../repo/settingsRepoFactory';
+import { cassandraDBHelpers } from '../../../repo/cassandraDBHelpers';
+import { SettingsRepo } from '../../../repo/settingsRepo';
+import { getUnifiedProfile } from '../../../unified-profile/unifiedProfileUtils';
+
+jest.mock('../../../unified-profile/unifiedProfileUtils');
+
+const USER_ID = 'AAABBBCCC';
+
+const languageAppSettings = {
+  secondaryLanguages: {
+    options: ['en', 'fr', 'sk'],
+    setting_type: 'array',
+  },
+  primaryLanguage: {
+    options: ['en', 'fr', 'sk'],
+    setting_type: 'string',
+    default: 'en',
+  },
+};
+
+const settingsRepo: SettingsRepo = SettingsRepoFactory.accessOrCreateSingleton();
+afterEach(() => {
+  jest.resetAllMocks();
+});
+
+describe('getUserSettings backup language', () => {
+  it('should get backup language from unified profile language array when no language found in general settings, looks up via taxonomy peoples array', async () => {
+    settingsRepo.getAppSettings = jest.fn().mockReturnValue(languageAppSettings);
+    const mockUserResultSet = {
+      rows: [],
+    };
+    cassandraDBHelpers.execute = jest.fn().mockResolvedValueOnce(mockUserResultSet);
+    const spyOnUpdateSettings = jest
+      .spyOn(settingsRepo, 'updateUserSettings')
+      .mockResolvedValueOnce(true)
+      .mockResolvedValueOnce(true);
+
+    const mockedProfileCall = getUnifiedProfile as jest.Mock;
+    mockedProfileCall.mockResolvedValueOnce({ content: { languages: ['French (Belgium)'] } });
+
+    const userSettings = await settingsRepo.getUserSettings(USER_ID, 'general');
+    expect(userSettings).toBeDefined();
+    expect(userSettings.primaryLanguage).toBe('fr');
+    expect(spyOnUpdateSettings).toHaveBeenCalled();
+    expect(spyOnUpdateSettings).toHaveBeenCalledTimes(2);
+    expect(spyOnUpdateSettings).toHaveBeenCalledWith(USER_ID, 'general', 'primaryLanguage', 'fr');
+  });
+  it('should get backup language from unified profile language array when no language found in general settings, looks up via taxonomy peoples string instead of array', async () => {
+    settingsRepo.getAppSettings = jest.fn().mockReturnValue(languageAppSettings);
+    const mockUserResultSet = {
+      rows: [],
+    };
+    cassandraDBHelpers.execute = jest.fn().mockResolvedValueOnce(mockUserResultSet);
+    const spyOnUpdateSettings = jest
+      .spyOn(settingsRepo, 'updateUserSettings')
+      .mockResolvedValueOnce(true)
+      .mockResolvedValueOnce(true);
+
+    const mockedProfileCall = getUnifiedProfile as jest.Mock;
+    mockedProfileCall.mockResolvedValueOnce({ content: { languages: ['Finnish'] } });
+
+    const userSettings = await settingsRepo.getUserSettings(USER_ID, 'general');
+    expect(userSettings).toBeDefined();
+    expect(userSettings.primaryLanguage).toBe('fi');
+    expect(spyOnUpdateSettings).toHaveBeenCalled();
+    expect(spyOnUpdateSettings).toHaveBeenCalledTimes(2);
+    expect(spyOnUpdateSettings).toHaveBeenCalledWith(USER_ID, 'general', 'primaryLanguage', 'fi');
+  });
+  it('should get backup language from unified profile preferredLanguage when no language in general settings and there is more than 1 language from UP', async () => {
+    settingsRepo.getAppSettings = jest.fn().mockReturnValue(languageAppSettings);
+    const mockUserResultSet: any = {
+      rows: [],
+    };
+    cassandraDBHelpers.execute = jest.fn().mockResolvedValueOnce(mockUserResultSet);
+    const spyOnUpdateSettings = jest
+      .spyOn(settingsRepo, 'updateUserSettings')
+      .mockResolvedValueOnce(true)
+      .mockResolvedValueOnce(true);
+
+    const mockedProfileCall = getUnifiedProfile as jest.Mock;
+    mockedProfileCall.mockResolvedValueOnce({
+      content: { languages: ['Chinese', 'French (Belgium)'], preferredLanguage: 'French (Belgium)' },
+    });
+
+    const userSettings = await settingsRepo.getUserSettings(USER_ID, 'general');
+    expect(userSettings).toBeDefined();
+    expect(userSettings.primaryLanguage).toBe('fr');
+    expect(spyOnUpdateSettings).toHaveBeenCalled();
+    expect(spyOnUpdateSettings).toHaveBeenCalledTimes(2);
+    expect(spyOnUpdateSettings).toHaveBeenCalledWith(USER_ID, 'general', 'primaryLanguage', 'fr');
+  });
+  it('should return default setting when no preferred language found from Unified Profile', async () => {
+    settingsRepo.getAppSettings = jest.fn().mockReturnValue(languageAppSettings);
+    const mockUserResultSet = {
+      rows: [],
+    };
+    cassandraDBHelpers.execute = jest.fn().mockResolvedValueOnce(mockUserResultSet);
+    const spyOnUpdateSettings = jest
+      .spyOn(settingsRepo, 'updateUserSettings')
+      .mockResolvedValueOnce(true)
+      .mockResolvedValueOnce(true);
+
+    const mockedProfileCall = getUnifiedProfile as jest.Mock;
+    mockedProfileCall.mockResolvedValueOnce({ content: { languages: ['Chinese', 'French (Belgium)'] } });
+
+    const userSettings = await settingsRepo.getUserSettings(USER_ID, 'general');
+
+    expect(userSettings).toBeDefined();
+    expect(userSettings.primaryLanguage).toBe('en');
+    expect(spyOnUpdateSettings).toHaveBeenCalled();
+    expect(spyOnUpdateSettings).toHaveBeenCalledTimes(2);
+    expect(spyOnUpdateSettings).toHaveBeenCalledWith(USER_ID, 'general', 'primaryLanguage', 'en');
+  });
+  it('should return default setting when no language found from Unified Profile', async () => {
+    settingsRepo.getAppSettings = jest.fn().mockReturnValue(languageAppSettings);
+    const mockUserResultSet = {
+      rows: [],
+    };
+    cassandraDBHelpers.execute = jest.fn().mockResolvedValueOnce(mockUserResultSet);
+    const spyOnUpdateSettings = jest
+      .spyOn(settingsRepo, 'updateUserSettings')
+      .mockResolvedValueOnce(true)
+      .mockResolvedValueOnce(true);
+
+    const mockedProfileCall = getUnifiedProfile as jest.Mock;
+    mockedProfileCall.mockResolvedValueOnce({ content: {} });
+
+    const userSettings = await settingsRepo.getUserSettings(USER_ID, 'general');
+
+    expect(userSettings).toBeDefined();
+    expect(userSettings.primaryLanguage).toBe('en');
+    expect(spyOnUpdateSettings).toHaveBeenCalled();
+    expect(spyOnUpdateSettings).toHaveBeenCalledTimes(2);
+    expect(spyOnUpdateSettings).toHaveBeenCalledWith(USER_ID, 'general', 'primaryLanguage', 'en');
+  });
+  it('should return default setting when an unsupported/bad language is found from Unified Profile languages array', async () => {
+    settingsRepo.getAppSettings = jest.fn().mockReturnValue(languageAppSettings);
+    const mockUserResultSet = {
+      rows: [],
+    };
+    cassandraDBHelpers.execute = jest.fn().mockResolvedValueOnce(mockUserResultSet);
+    const spyOnUpdateSettings = jest
+      .spyOn(settingsRepo, 'updateUserSettings')
+      .mockResolvedValueOnce(true)
+      .mockResolvedValueOnce(true);
+
+    const mockedProfileCall = getUnifiedProfile as jest.Mock;
+    mockedProfileCall.mockResolvedValueOnce({ content: { languages: ['UngaBunga'] } });
+    const userSettings = await settingsRepo.getUserSettings(USER_ID, 'general');
+    expect(userSettings).toBeDefined();
+    expect(userSettings.primaryLanguage).toBe('en');
+    expect(spyOnUpdateSettings).toHaveBeenCalled();
+    expect(spyOnUpdateSettings).toHaveBeenCalledTimes(2);
+    expect(spyOnUpdateSettings).toHaveBeenCalledWith(USER_ID, 'general', 'primaryLanguage', 'en');
+  });
+  it('should return default setting when an unsupported/bad language is found', async () => {
+    settingsRepo.getAppSettings = jest.fn().mockReturnValue(languageAppSettings);
+    const mockUserResultSet = {
+      rows: [],
+    };
+    cassandraDBHelpers.execute = jest.fn().mockResolvedValueOnce(mockUserResultSet);
+    const spyOnUpdateSettings = jest
+      .spyOn(settingsRepo, 'updateUserSettings')
+      .mockResolvedValueOnce(true)
+      .mockResolvedValueOnce(true);
+
+    const mockedProfileCall = getUnifiedProfile as jest.Mock;
+    mockedProfileCall.mockResolvedValueOnce({
+      content: { languages: ['UngaBunga', 'French (Belgium)'], preferredLanguage: 'UngaBunga' },
+    });
+    const userSettings = await settingsRepo.getUserSettings(USER_ID, 'general');
+    expect(userSettings).toBeDefined();
+    expect(userSettings.primaryLanguage).toBe('en');
+    expect(spyOnUpdateSettings).toHaveBeenCalled();
+    expect(spyOnUpdateSettings).toHaveBeenCalledTimes(2);
+    expect(spyOnUpdateSettings).toHaveBeenCalledWith(USER_ID, 'general', 'primaryLanguage', 'en');
+  });
+  it('should get backup language from unified profile preferredLanguage when no language in general settings and there is more than 1 language from UP, looks up peoples array', async () => {
+    settingsRepo.getAppSettings = jest.fn().mockReturnValue(languageAppSettings);
+    const mockUserResultSet = {
+      rows: [],
+    };
+    cassandraDBHelpers.execute = jest.fn().mockResolvedValueOnce(mockUserResultSet);
+    const spyOnUpdateSettings = jest
+      .spyOn(settingsRepo, 'updateUserSettings')
+      .mockResolvedValueOnce(true)
+      .mockResolvedValueOnce(true);
+
+    const mockedProfileCall = getUnifiedProfile as jest.Mock;
+    mockedProfileCall.mockResolvedValueOnce({
+      content: { languages: ['Chinese', 'French'], preferredLanguage: 'Portuguese (Brazil)' },
+    });
+
+    const userSettings = await settingsRepo.getUserSettings(USER_ID, 'general');
+    expect(userSettings).toBeDefined();
+    expect(userSettings.primaryLanguage).toBe('pt');
+    expect(spyOnUpdateSettings).toHaveBeenCalled();
+    expect(spyOnUpdateSettings).toHaveBeenCalledTimes(2);
+    expect(spyOnUpdateSettings).toHaveBeenCalledWith(USER_ID, 'general', 'primaryLanguage', 'pt');
+  });
+  it('should get backup language from unified profile preferredLanguage when an unsupported/bad language is found from Unified Profile languages array of size 1, looks up peoples array', async () => {
+    settingsRepo.getAppSettings = jest.fn().mockReturnValue(languageAppSettings);
+    const mockUserResultSet = {
+      rows: [],
+    };
+    cassandraDBHelpers.execute = jest.fn().mockResolvedValueOnce(mockUserResultSet);
+    const spyOnUpdateSettings = jest
+      .spyOn(settingsRepo, 'updateUserSettings')
+      .mockResolvedValueOnce(true)
+      .mockResolvedValueOnce(true);
+
+    const mockedProfileCall = getUnifiedProfile as jest.Mock;
+    mockedProfileCall.mockResolvedValueOnce({
+      content: { languages: ['UngaBunga'], preferredLanguage: 'Portuguese (Brazil)' },
+    });
+    const userSettings = await settingsRepo.getUserSettings(USER_ID, 'general');
+    expect(userSettings).toBeDefined();
+    expect(userSettings.primaryLanguage).toBe('pt');
+    expect(spyOnUpdateSettings).toHaveBeenCalled();
+    expect(spyOnUpdateSettings).toHaveBeenCalledTimes(2);
+    expect(spyOnUpdateSettings).toHaveBeenCalledWith(USER_ID, 'general', 'primaryLanguage', 'pt');
+  });
+  it('should get backup language from unified profile preferredLanguage when an unsupported/bad language is found from Unified Profile languages array, looks up peoples array', async () => {
+    settingsRepo.getAppSettings = jest.fn().mockReturnValue(languageAppSettings);
+    const mockUserResultSet = {
+      rows: [],
+    };
+    cassandraDBHelpers.execute = jest.fn().mockResolvedValueOnce(mockUserResultSet);
+    const spyOnUpdateSettings = jest
+      .spyOn(settingsRepo, 'updateUserSettings')
+      .mockResolvedValueOnce(true)
+      .mockResolvedValueOnce(true);
+
+    const mockedProfileCall = getUnifiedProfile as jest.Mock;
+    mockedProfileCall.mockResolvedValueOnce({
+      content: {
+        languages: ['UngaBunga', 'Portuguese (Brazil)'],
+        preferredLanguage: 'Portuguese (Brazil)',
+      },
+    });
+    const userSettings = await settingsRepo.getUserSettings(USER_ID, 'general');
+    expect(userSettings).toBeDefined();
+    expect(userSettings.primaryLanguage).toBe('pt');
+    expect(spyOnUpdateSettings).toHaveBeenCalled();
+    expect(spyOnUpdateSettings).toHaveBeenCalledTimes(2);
+    expect(spyOnUpdateSettings).toHaveBeenCalledWith(USER_ID, 'general', 'primaryLanguage', 'pt');
+  });
+});