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

package/settings-service/src/__tests__/functional/unified-profile/unified-profile.fn.ts

@@ -0,0 +1,66 @@
+import axios from 'axios';
+import http from 'axios/lib/adapters/http';
+import { ApiKeyRepoFactory } from '../../../repo/ApiKeyRepoFactory';
+import { deleteApiKeyQuery } from '../../../repo/apiKeyQueries';
+import { ApiKeyRepo } from '../../../repo/ApiKeyRepo';
+import { SettingsRepo } from '../../../repo/settingsRepo';
+import { TEST_APP_ID } from '../../utils/test-utils';
+import { SettingsRepoFactory } from '../../../repo/settingsRepoFactory';
+import { cassandraDBHelpers } from '../../../repo/cassandraDBHelpers';
+import { downloadCassandra } from '../../../util/downloadCassandra';
+
+axios.defaults.adapter = http;
+
+const FAKE_USER_ID = 'TEST_USER';
+
+// broadcast ID has a Unified Profile but no stored settings in settings-service
+const TEST_BROADCAST_ID = 'C-RR67897';
+
+async function apiKeySetup(): Promise<string> {
+  const apiKeyRepo: ApiKeyRepo = ApiKeyRepoFactory.accessOrCreateSingleton();
+  const createdApiKey = await apiKeyRepo.createApiKey(TEST_APP_ID, 'TEST_USER_ID');
+  return Buffer.from(`w3notifications-test:${createdApiKey}`).toString('base64');
+}
+
+let TEST_HEADER_API: any = {};
+
+const urlprefix =
+  process.env.INGRESS_HOSTNAME !== undefined
+    ? `https://${process.env.INGRESS_HOSTNAME}`
+    : 'http://localhost:8000';
+
+const settingsRepo: SettingsRepo = SettingsRepoFactory.accessOrCreateSingleton();
+
+describe('unified-profile backup call', () => {
+  const TEST_RESP = { general: {} };
+  TEST_RESP[TEST_APP_ID] = {};
+
+  beforeAll(async () => {
+    await downloadCassandra();
+    await settingsRepo.deleteUserSettings(FAKE_USER_ID);
+    await settingsRepo.deleteUserSettings(TEST_BROADCAST_ID);
+    TEST_HEADER_API = { headers: { Authorization: `apiKey ${await apiKeySetup()}` } };
+  });
+
+  afterAll(async () => {
+    await settingsRepo.deleteUserSettings(FAKE_USER_ID);
+    await settingsRepo.deleteUserSettings(TEST_BROADCAST_ID);
+    await cassandraDBHelpers.execute(deleteApiKeyQuery, [TEST_APP_ID]);
+    await cassandraDBHelpers.shutdown();
+  });
+
+  it('returns default language when no primary language in unified profile', async () => {
+    const data = await axios
+      .get(`${urlprefix}/v1/settings/users/${FAKE_USER_ID}/apps/general`, TEST_HEADER_API)
+      .then((res) => res.data);
+    expect(data.general.primaryLanguage).toEqual('en');
+  });
+
+  it('returns language from Unified Profile when no primary language in settings service', async () => {
+    // TEST_BROADCAST_ID has a unified profile, but no settings in settings-service
+    const data = await axios
+      .get(`${urlprefix}/v1/settings/users/${TEST_BROADCAST_ID}/apps/general`, TEST_HEADER_API)
+      .then((res) => res.data);
+    expect(data.general.primaryLanguage).toEqual('en');
+  });
+});

package/settings-service/src/__tests__/integration/repo/ApiKeyRepo.it.ts

@@ -0,0 +1,43 @@
+import { ApiKeyRepoFactory } from '../../../repo/ApiKeyRepoFactory';
+import { deleteApiKeyQuery } from '../../../repo/apiKeyQueries';
+import { ApiKeyRepo } from '../../../repo/ApiKeyRepo';
+import { cassandraDBHelpers } from '../../../repo/cassandraDBHelpers';
+import { TEST_APP_ID, TEST_USER_ID } from '../../utils/test-utils';
+
+beforeAll(async () => {
+  await cassandraDBHelpers.execute(deleteApiKeyQuery, [TEST_APP_ID]);
+});
+afterAll(async () => {
+  await cassandraDBHelpers.execute(deleteApiKeyQuery, [TEST_APP_ID]);
+  await cassandraDBHelpers.shutdown();
+});
+
+describe('cassandra apiKey integration', () => {
+  let originalApiKey: string;
+  const apiKeyRepo: ApiKeyRepo = ApiKeyRepoFactory.accessOrCreateSingleton();
+
+  it('should create api key in database', async () => {
+    const res = await apiKeyRepo.createApiKey(TEST_APP_ID, TEST_USER_ID);
+    originalApiKey = res;
+
+    expect(res).toBeDefined();
+    expect(typeof res).toBe('string');
+    expect(res).toHaveLength(48);
+  });
+
+  it('should get correct apiKey from database', async () => {
+    const res = await apiKeyRepo.getApiKey(TEST_APP_ID);
+
+    expect(res).toBeDefined();
+    expect(res.key).toEqual(originalApiKey);
+  });
+
+  it('should update api key in database', async () => {
+    const res = await apiKeyRepo.updateApiKey(TEST_APP_ID, TEST_USER_ID);
+
+    expect(res).toBeDefined();
+    expect(res).not.toEqual(originalApiKey);
+    expect(typeof res).toBe('string');
+    expect(res).toHaveLength(48);
+  });
+});

package/settings-service/src/__tests__/integration/repo/settingsRepo.it.ts

@@ -0,0 +1,142 @@
+import axios from 'axios';
+import { ApiKeyRepoFactory } from '../../../repo/ApiKeyRepoFactory';
+import { deleteApiKeyQuery } from '../../../repo/apiKeyQueries';
+import { ApiKeyRepo } from '../../../repo/ApiKeyRepo';
+import { cassandraDBHelpers } from '../../../repo/cassandraDBHelpers';
+import { SettingsRepo } from '../../../repo/settingsRepo';
+import { fetchAppSettingsDataQuery, fetchUserSettingsDataQuery } from '../../../repo/settingsRepoQueries';
+import { sampleAuthorization, TEST_APP_ID, TEST_USER_ID } from '../../utils/test-utils';
+import { SettingsRepoFactory } from '../../../repo/settingsRepoFactory';
+
+const TEST_SETTING = 'test';
+const TEST_OPTIONS = ['dark'];
+const TEST_SETTING_OPTIONS = { test: { options: TEST_OPTIONS, default: null } };
+
+const settingsRepo: SettingsRepo = SettingsRepoFactory.accessOrCreateSingleton();
+
+describe('cassandra integration', () => {
+  const TEST_RESP = {};
+  TEST_RESP[TEST_APP_ID] = TEST_SETTING_OPTIONS;
+
+  beforeAll(async () => {
+    await settingsRepo.deleteUserSettings(TEST_USER_ID);
+    await settingsRepo.deleteAppSettings(TEST_APP_ID, TEST_SETTING);
+  });
+
+  afterAll(async () => {
+    await settingsRepo.deleteUserSettings(TEST_USER_ID);
+    await settingsRepo.deleteAppSettings(TEST_APP_ID, TEST_SETTING);
+  });
+
+  it('updates app setting', async () => {
+    const res = await settingsRepo.updateAppSettings({
+      appId: TEST_APP_ID,
+      settingName: TEST_SETTING,
+      settingOptions: TEST_OPTIONS,
+    });
+    expect(res).toEqual(true);
+  });
+
+  it('reads updated app settings', async () => {
+    const res = await settingsRepo.getAppSettings(TEST_APP_ID, TEST_SETTING);
+    expect(res).toEqual(TEST_RESP[TEST_APP_ID]);
+  });
+
+  it('updates user data', async () => {
+    const res = await settingsRepo.updateUserSettings(
+      TEST_USER_ID,
+      TEST_APP_ID,
+      TEST_SETTING,
+      TEST_OPTIONS[0],
+    );
+    expect(res).toEqual(true);
+  });
+
+  it('reads updated user settings', async () => {
+    const res = await settingsRepo.getUserSettings(TEST_USER_ID, TEST_APP_ID);
+    expect(res[TEST_SETTING]).toEqual(TEST_OPTIONS[0]);
+  });
+
+  it('deletes user settings', async () => {
+    const res = await settingsRepo.deleteUserSettings(TEST_USER_ID);
+    expect(res).toEqual(true);
+  });
+
+  it('deletes app settings', async () => {
+    const res = await settingsRepo.deleteAppSettings(TEST_APP_ID, TEST_SETTING);
+    expect(res).toEqual(true);
+  });
+});
+
+describe('array value storage tests', () => {
+  it('reads general settings', async () => {
+    await cassandraDBHelpers.execute(fetchAppSettingsDataQuery, ['general']).then((results) => {
+      const settingsAndDefaults: Map<string, string> = new Map<string, string>();
+      for (const row of results.rows) {
+        const { setting_name } = row;
+        const { setting_default } = row;
+        settingsAndDefaults.set(setting_name, setting_default);
+      }
+      expect(settingsAndDefaults.get('primaryLanguage')).toBe('en');
+      expect(settingsAndDefaults.get('secondaryLanguages')).toBe(null);
+      expect(settingsAndDefaults.get('secondaryLocationIds')).toBe(null);
+    });
+  });
+});
+
+describe('array value storage tests', () => {
+  const TEST_HEADER = { headers: { Authorization: `Bearer ${JSON.stringify(sampleAuthorization)}` } };
+  const urlprefix =
+    process.env.INGRESS_HOSTNAME !== undefined
+      ? `https://${process.env.INGRESS_HOSTNAME}`
+      : 'http://localhost:8000';
+
+  async function apiKeySetup(): Promise<string> {
+    const apiKeyRepo: ApiKeyRepo = ApiKeyRepoFactory.accessOrCreateSingleton();
+    const createdApiKey = await apiKeyRepo.createApiKey(TEST_APP_ID, 'TEST_USER_ID');
+    return Buffer.from(`w3notifications-test:${createdApiKey}`).toString('base64');
+  }
+  let TEST_HEADER_API: any = {};
+
+  const secondaryLanguageSetting = { options: ['sk', 'en', 'fr'], setting_type: 'array' };
+
+  beforeAll(async () => {
+    await settingsRepo.deleteUserSettings(TEST_USER_ID);
+    await settingsRepo.deleteAppSettings(TEST_APP_ID, 'secondaryLanguages');
+    TEST_HEADER_API = { headers: { Authorization: `apiKey ${await apiKeySetup()}` } };
+    await axios.post(
+      `${urlprefix}/v1/settings/app/${TEST_APP_ID}/setting/secondaryLanguages`,
+      secondaryLanguageSetting,
+      TEST_HEADER_API,
+    );
+  });
+
+  afterAll(async () => {
+    await settingsRepo.deleteUserSettings(TEST_USER_ID);
+    await cassandraDBHelpers.execute(deleteApiKeyQuery, [TEST_APP_ID]);
+    await settingsRepo.deleteAppSettings(TEST_APP_ID, 'secondaryLanguages');
+    await cassandraDBHelpers.shutdown();
+  });
+
+  it('can post an array value and store as a string', async () => {
+    const updatedSetting = { secondaryLanguages: ['en', 'fr'] };
+    await axios.post(
+      `${urlprefix}/v1/settings/users/${TEST_USER_ID}/apps/${TEST_APP_ID}`,
+      updatedSetting,
+      TEST_HEADER,
+    );
+
+    await cassandraDBHelpers
+      .execute(fetchUserSettingsDataQuery, [TEST_USER_ID, TEST_APP_ID])
+      .then((results) => {
+        expect(results.rows[0].setting_value).toBe('en,fr');
+      });
+  });
+
+  it('can retrieve a string value and return as array', async () => {
+    const data = await axios
+      .get(`${urlprefix}/v1/settings/users/${TEST_USER_ID}/apps/${TEST_APP_ID}`, TEST_HEADER)
+      .then((res) => res.data);
+    expect(data[TEST_APP_ID].secondaryLanguages).toEqual(['en', 'fr']);
+  });
+});

package/settings-service/src/__tests__/integration/unified-profile/unified-profile.it.ts

@@ -0,0 +1,31 @@
+import { SettingsRepoFactory } from '../../../repo/settingsRepoFactory';
+import { cassandraDBHelpers } from '../../../repo/cassandraDBHelpers';
+import { SettingsRepo } from '../../../repo/settingsRepo';
+
+const TEST_USER_ID = 'TESTUSER';
+
+const settingsRepo: SettingsRepo = SettingsRepoFactory.accessOrCreateSingleton();
+
+// broadcast ID has a Unified Profile but no stored settings in settings-service
+const TEST_BROADCAST_ID = 'C-RR67897';
+
+describe('unified-profile backup call', () => {
+  beforeEach(async () => {
+    await settingsRepo.deleteUserSettings(TEST_USER_ID);
+    await settingsRepo.deleteUserSettings(TEST_BROADCAST_ID);
+  });
+  afterAll(async () => {
+    await settingsRepo.deleteUserSettings(TEST_USER_ID);
+    await settingsRepo.deleteUserSettings(TEST_BROADCAST_ID);
+    await cassandraDBHelpers.shutdown();
+  });
+  it('returns default language setting if user does not have a profile', async () => {
+    const res = await settingsRepo.getUserSettings(TEST_USER_ID, 'general');
+    expect(res.primaryLanguage).toEqual('en');
+  });
+  it('returns language from unified profile if no primary language in settings-service', async () => {
+    // TEST_BROADCAST_ID has a unified profile, but no stored settings in settings-service
+    const res = await settingsRepo.getUserSettings(TEST_BROADCAST_ID, 'general');
+    expect(res.primaryLanguage).toEqual('en');
+  });
+});

package/settings-service/src/__tests__/unit/ErrResponse.ts

@@ -0,0 +1,4 @@
+export interface ErrResponse {
+  code: number;
+  message: string;
+}

package/settings-service/src/__tests__/unit/JWTResponse.ts

@@ -0,0 +1,18 @@
+export const jwtResponse = {
+  id: 'John.Doe@ibm.com',
+  cn: 'John Doe',
+  uid: 'AAABBB555',
+  isW3HomepageAdmin: false,
+  hkey: 'b342d835af74c094d868829d2099c04c1eb81351c2078265c3227559fc80959e',
+  iat: 1548773356,
+  exp: 1548816556,
+};
+
+export const jwtBadResponse = {
+  id: 'John.Doe@ibm.com',
+  cn: 'John Doe',
+  isW3HomepageAdmin: false,
+  hkey: 'b342d835af74c094d868829d2099c04c1eb81351c2078265c3227559fc80959e',
+  iat: 1548773356,
+  exp: 1548816556,
+};

package/settings-service/src/__tests__/unit/bluepagesResponse.ts

@@ -0,0 +1,25 @@
+export const bluepagesResponse = {
+  userId: 'AAABBB555',
+  active: true,
+  content: {
+    user: {
+      profile: {
+        uid: 'AAABBB555',
+        id: 'AAABBB555',
+        email: 'John.Doe@ibm.com',
+        notesMailDomain: 'IBM',
+        nameFull: 'John Doe',
+        courtesyTitle: 'Mr.',
+        nameDisplay: 'John Doe',
+        notesShortName: 'AAABBB',
+        name: {
+          last: 'Doe',
+          first: 'John',
+        },
+        preferredIdentity: 'John.Doe@ibm.com',
+        callup: 'Doe, John B (JOHN)',
+        notes: 'John Doe/US/IBM',
+      },
+    },
+  },
+};

package/settings-service/src/__tests__/unit/controller/ApiKeyController.spec.ts

@@ -0,0 +1,217 @@
+import { Request, Response } from 'restify';
+import { settings } from '../../../config/config';
+import { fetchApiKey, postApiKey, putApiKey } from '../../../controller/ApiKeyController';
+import { ApiKeyRepoImpl } from '../../../repo/ApiKeyRepo';
+import {
+  INVALID_APP_ID,
+  mockApiKey,
+  TEST_API_KEY,
+  TEST_APP_ID,
+  TEST_USER_ID,
+} from '../../utils/test-utils';
+
+settings.settingsAppIds = ['w3notifications-test', 'general'];
+
+afterEach(() => {
+  jest.resetAllMocks();
+});
+
+function test_send(code?: number | undefined, body?: any): any {
+  return { code, body };
+}
+
+describe('fetchApiKey', () => {
+  const request: Request = {} as Request;
+  const response: Response = {} as Response;
+  response.send = test_send;
+
+  it('should respond with 200 and send apiKey for valid appID', async () => {
+    request.params = { appID: TEST_APP_ID };
+
+    const getApiKeySpy = jest.spyOn(ApiKeyRepoImpl.prototype, 'getApiKey').mockResolvedValue(mockApiKey);
+
+    const responseObj: any = await fetchApiKey(request, response);
+
+    expect(responseObj.code).toEqual(200);
+    expect(responseObj.body).toEqual(mockApiKey);
+    expect(getApiKeySpy).toHaveBeenCalled();
+  });
+
+  it('should respond with 400 when no appID provided', async () => {
+    request.params = {};
+
+    const responseObj: any = await fetchApiKey(request, response);
+
+    expect(responseObj.code).toEqual(400);
+    expect(responseObj.body.message).toEqual('Missing required query params.');
+  });
+
+  it('should respond with 400 when appId invalid', async () => {
+    request.params = { appID: INVALID_APP_ID };
+    const getApiKeySpy = jest.spyOn(ApiKeyRepoImpl.prototype, 'createApiKey');
+
+    const responseObj: any = await fetchApiKey(request, response);
+
+    expect(responseObj.code).toEqual(400);
+    expect(responseObj.body.message).toEqual('Invalid appID');
+    expect(getApiKeySpy).not.toHaveBeenCalled();
+  });
+
+  it('should respond with 500 if error caught', async () => {
+    request.params = { appID: TEST_APP_ID };
+    const getApiKeySpy = jest.spyOn(ApiKeyRepoImpl.prototype, 'getApiKey').mockImplementationOnce(() => {
+      throw new Error('error in getApiKey');
+    });
+
+    const responseObj: any = await fetchApiKey(request, response);
+
+    expect(responseObj.code).toEqual(500);
+    expect(responseObj.body.message).toEqual('Unable to fetch Api Key');
+    expect(getApiKeySpy).toHaveBeenCalled();
+  });
+});
+
+describe('postApiKey', () => {
+  const request: Request = {} as Request;
+  const response: Response = {} as Response;
+  response.send = test_send;
+
+  it('should respond with 200 when key successfully created', async () => {
+    request.params = { appID: TEST_APP_ID };
+    request.username = TEST_USER_ID;
+    const createApiKeySpy = jest
+      .spyOn(ApiKeyRepoImpl.prototype, 'createApiKey')
+      .mockResolvedValueOnce(TEST_API_KEY);
+
+    const responseObj: any = await postApiKey(request, response);
+
+    expect(responseObj.code).toEqual(200);
+    expect(responseObj.body.key).toEqual(mockApiKey.key);
+    expect(createApiKeySpy).toHaveBeenCalled();
+  });
+
+  it('should respond with 400 when missing appId', async () => {
+    request.params = {};
+    request.username = TEST_USER_ID;
+    const createApiKeySpy = jest.spyOn(ApiKeyRepoImpl.prototype, 'createApiKey');
+    const responseObj: any = await postApiKey(request, response);
+
+    expect(responseObj.code).toEqual(400);
+    expect(responseObj.body.message).toEqual('Missing required query params.');
+    expect(createApiKeySpy).not.toHaveBeenCalled();
+  });
+
+  it('should respond with 400 when missing username', async () => {
+    request.params = { appID: TEST_APP_ID };
+    request.username = undefined;
+    const createApiKeySpy = jest.spyOn(ApiKeyRepoImpl.prototype, 'createApiKey');
+
+    const responseObj: any = await postApiKey(request, response);
+
+    expect(responseObj.code).toEqual(400);
+    expect(responseObj.body.message).toEqual('Missing request username');
+    expect(createApiKeySpy).not.toHaveBeenCalled();
+  });
+
+  it('should respond with 400 when appId invalid', async () => {
+    request.params = { appID: INVALID_APP_ID };
+    request.username = TEST_USER_ID;
+    const createApiKeySpy = jest.spyOn(ApiKeyRepoImpl.prototype, 'createApiKey');
+
+    const responseObj: any = await postApiKey(request, response);
+
+    expect(responseObj.code).toEqual(400);
+    expect(responseObj.body.message).toEqual('Invalid appID');
+    expect(createApiKeySpy).not.toHaveBeenCalled();
+  });
+
+  it('should respond with 500 if error caught', async () => {
+    request.params = { appID: TEST_APP_ID };
+    request.username = TEST_USER_ID;
+
+    const createApiKeySpy = jest
+      .spyOn(ApiKeyRepoImpl.prototype, 'createApiKey')
+      .mockImplementationOnce(() => {
+        throw new Error('error in createApiKey');
+      });
+
+    const responseObj: any = await postApiKey(request, response);
+
+    expect(responseObj.code).toEqual(500);
+    expect(responseObj.body.message).toEqual('Unable to create api key');
+    expect(createApiKeySpy).toHaveBeenCalled();
+  });
+});
+
+describe('putApiKey', () => {
+  const request: Request = {} as Request;
+  const response: Response = {} as Response;
+  response.send = test_send;
+
+  it('should respond with 200 when updating apiKey', async () => {
+    request.params = { appID: TEST_APP_ID };
+    request.username = TEST_USER_ID;
+
+    const updateApiKeySpy = jest
+      .spyOn(ApiKeyRepoImpl.prototype, 'updateApiKey')
+      .mockResolvedValueOnce(TEST_API_KEY);
+
+    const responseObj: any = await putApiKey(request, response);
+
+    expect(responseObj.code).toEqual(200);
+    expect(responseObj.body.key).toEqual(TEST_API_KEY);
+    expect(updateApiKeySpy).toHaveBeenCalled();
+  });
+
+  it('should respond with 400 when missing appId', async () => {
+    request.params = {};
+    request.username = TEST_USER_ID;
+    const updateApiKeySpy = jest.spyOn(ApiKeyRepoImpl.prototype, 'updateApiKey');
+    const responseObj: any = await putApiKey(request, response);
+
+    expect(responseObj.code).toEqual(400);
+    expect(responseObj.body.message).toEqual('Missing required query params.');
+    expect(updateApiKeySpy).not.toHaveBeenCalled();
+  });
+
+  it('should respond with 400 when missing username', async () => {
+    request.params = { appID: TEST_APP_ID };
+    request.username = undefined;
+    const updateApiKeySpy = jest.spyOn(ApiKeyRepoImpl.prototype, 'updateApiKey');
+
+    const responseObj: any = await putApiKey(request, response);
+
+    expect(responseObj.code).toEqual(400);
+    expect(responseObj.body.message).toEqual('Missing request username');
+    expect(updateApiKeySpy).not.toHaveBeenCalled();
+  });
+
+  it('should respond with 400 when appId invalid', async () => {
+    request.params = { appID: INVALID_APP_ID };
+    request.username = TEST_USER_ID;
+    const updateApiKeySpy = jest.spyOn(ApiKeyRepoImpl.prototype, 'updateApiKey');
+
+    const responseObj: any = await putApiKey(request, response);
+
+    expect(responseObj.code).toEqual(400);
+    expect(responseObj.body.message).toEqual('Invalid appID');
+    expect(updateApiKeySpy).not.toHaveBeenCalled();
+  });
+
+  it('should respond with 500 if error caught', async () => {
+    request.params = { appID: TEST_APP_ID };
+    request.username = TEST_USER_ID;
+
+    const updateApiKeySpy = jest
+      .spyOn(ApiKeyRepoImpl.prototype, 'updateApiKey')
+      .mockImplementationOnce(() => {
+        throw new Error('error in updateApiKey');
+      });
+
+    const responseObj: any = await putApiKey(request, response);
+
+    expect(responseObj.code).toEqual(500);
+    expect(responseObj.body.message).toEqual('Unable to update api key');
+    expect(updateApiKeySpy).toHaveBeenCalled();
+  });
+});

package/settings-service/src/__tests__/unit/controller/AppSettingsController.spec.ts

@@ -0,0 +1,133 @@
+import { Request, Response } from 'restify';
+import { settings } from '../../../config/config';
+import {
+  deleteAppSettings,
+  getAppSettings,
+  postAppSettings,
+} from '../../../controller/AppSettingsController';
+import { cassandraDBHelpers } from '../../../repo/cassandraDBHelpers';
+import { INVALID_APP_ID, TEST_APP_ID } from '../../utils/test-utils';
+
+settings.settingsAppIds = ['w3notifications-test', 'general'];
+
+const SETTING_NAME = 'test';
+const SETTING_OPTIONS = ['true', 'false'];
+
+function test_send(code?: number | undefined): any {
+  return code;
+}
+
+describe('get settings using appID', () => {
+  const request: Request = {} as Request;
+  const response: Response = {} as Response;
+
+  request.params = { appID: TEST_APP_ID };
+  request.query = {};
+
+  it('should return 200 set while getting data', async () => {
+    const mockResultSet: any = {
+      rows: [],
+    };
+    cassandraDBHelpers.execute = jest.fn().mockReturnValue(
+      new Promise((resolve) => {
+        resolve(mockResultSet);
+      }),
+    );
+    response.send = test_send;
+    expect(await getAppSettings(request, response)).toEqual(200);
+  });
+  it('invalid appID should return 400 error', async () => {
+    request.params.appID = INVALID_APP_ID;
+    response.send = test_send;
+    expect(await getAppSettings(request, response)).toEqual(400);
+  });
+  it('internal server error should return 500 error', async () => {
+    request.params = undefined;
+    response.send = test_send;
+    expect(await getAppSettings(request, response)).toEqual(500);
+  });
+});
+
+describe('post settings', () => {
+  const request: Request = {} as Request;
+  const response: Response = {} as Response;
+
+  request.params = { appID: 'general', settingName: SETTING_NAME };
+  request.query = {};
+  request.body = { options: SETTING_OPTIONS, setting_type: null };
+
+  it('should return 200 set while posting data', async () => {
+    const mockResultSet: any = {
+      rows: [],
+    };
+    cassandraDBHelpers.execute = jest.fn().mockReturnValue(
+      new Promise((resolve) => {
+        resolve(mockResultSet);
+      }),
+    );
+    response.send = test_send;
+    expect(await postAppSettings(request, response)).toEqual(200);
+  });
+  it('json error should return 500 error', async () => {
+    request.body = [];
+    response.send = test_send;
+    expect(await postAppSettings(request, response)).toEqual(500);
+  });
+  it('invalid default should return 500 error', async () => {
+    request.body = { default: 'invalid', options: SETTING_OPTIONS };
+    response.send = test_send;
+    expect(await postAppSettings(request, response)).toEqual(500);
+  });
+  it('invalid input should return 400 error', async () => {
+    request.params.appID = INVALID_APP_ID;
+    response.send = test_send;
+    expect(await postAppSettings(request, response)).toEqual(400);
+    request.params.appID = null;
+    expect(await postAppSettings(request, response)).toEqual(400);
+  });
+  it('internal server error should return 500 error', async () => {
+    request.params = undefined;
+    response.send = test_send;
+    expect(await postAppSettings(request, response)).toEqual(500);
+  });
+  it('invalid setting_type will return 400 error', async () => {
+    const invalidType = 'invalid setting type';
+    request.body = { options: SETTING_OPTIONS, setting_type: invalidType };
+    response.send = test_send;
+    request.params = { appID: 'general', settingName: SETTING_NAME };
+    expect(await postAppSettings(request, response)).toEqual(400);
+  });
+});
+
+describe('delete settings', () => {
+  const request: Request = {} as Request;
+  const response: Response = {} as Response;
+
+  request.params = { appID: 'general', settingName: SETTING_NAME };
+  request.query = {};
+
+  it('should return 200 set while deleting data', async () => {
+    const mockResultSet: any = {
+      rows: [],
+    };
+    cassandraDBHelpers.execute = jest.fn().mockReturnValue(
+      new Promise((resolve) => {
+        resolve(mockResultSet);
+      }),
+    );
+    response.send = test_send;
+    expect(await deleteAppSettings(request, response)).toEqual(200);
+  });
+  it('invalid input should return 400 error', async () => {
+    request.params.appID = INVALID_APP_ID;
+    response.send = test_send;
+    expect(await deleteAppSettings(request, response)).toEqual(400);
+    request.params.appID = null;
+    expect(await deleteAppSettings(request, response)).toEqual(400);
+  });
+  it('internal server error should return 500 error', async () => {
+    request.params = undefined;
+    response.send = test_send;
+    expect(await deleteAppSettings(request, response)).toEqual(500);
+  });
+});