@bigid/apps-infrastructure-node-js 1.218.1 → 1.226.1

package/README.md

@@ -32,9 +32,6 @@ BIGID_REFRESH_TOKEN - refresh token that will be used to execute api calls
 
 ###Multi tenant mode
 BIGID_BASE_URL - bigid url
-
 AUTH0_DOMAIN - auth0 domain where the application configured - will be provided by BigID's application framework team
-
 CLIENT_ID - client id of the application in auth0 - will be provided by BigID's application framework team
-
 CLIENT_SECRET - client secret of the application - will be provided by BigID's application framework team

package/lib/services/actionsHubService.d.ts

@@ -22,13 +22,14 @@ export declare const getCommandsRegistrations: (accessToken?: string) => Promise
  *
  * @param {string} actionName - the action name to be executed.
  * @param {string} command    - the command to be executed.
+ * @param {string} applicationName - the application name that the command to be triggered belongs to
  * @param {string} requestorAppName - the app name of the execution requestor.
  * @param {string} webhookEndpoint - the endpoint of the requestor app to receive execution status messages.
  * @param {Record<string, any>} params - the relevant params of the action to be executed.
  * @param {string} accessToken -- the access token from BigId.
  * @return {Promise<string>} execution id of the executed action.
  */
-export declare const executeCommand: (actionName: string, command: string, requestorAppName?: string, webhookEndpoint?: string, params?: Record<string, any>[], accessToken?: string) => Promise<string>;
+export declare const executeCommand: (actionName: string, command: string, applicationName?: string, requestorAppName?: string, webhookEndpoint?: string, params?: Record<string, any>[], accessToken?: string) => Promise<string>;
 /**
  * use this method to poll an execution status from the action-center.
  *

package/lib/services/actionsHubService.js

@@ -36,17 +36,19 @@ exports.getCommandsRegistrations = getCommandsRegistrations;
  *
  * @param {string} actionName - the action name to be executed.
  * @param {string} command    - the command to be executed.
+ * @param {string} applicationName - the application name that the command to be triggered belongs to
  * @param {string} requestorAppName - the app name of the execution requestor.
  * @param {string} webhookEndpoint - the endpoint of the requestor app to receive execution status messages.
  * @param {Record<string, any>} params - the relevant params of the action to be executed.
  * @param {string} accessToken -- the access token from BigId.
  * @return {Promise<string>} execution id of the executed action.
  */
-const executeCommand = (actionName, command, requestorAppName, webhookEndpoint, params, accessToken) => __awaiter(void 0, void 0, void 0, function* () {
+const executeCommand = (actionName, command, applicationName, requestorAppName, webhookEndpoint, params, accessToken) => __awaiter(void 0, void 0, void 0, function* () {
     try {
         const bigidToken = accessToken || (yield (0, tokenUtil_1.getBigidAccessToken)());
         const { data: { executionId }, } = yield (0, bigidProxyService_1.doCallToUrl)(bigidToken, bigidProxyService_1.RequestMethod.POST, `${process.env.BIGID_BASE_URL}/api/v1/action-center/general-commands/execute`, Object.assign({ actionName,
-            command, feedbackRequestorDetails: requestorAppName && webhookEndpoint
+            command,
+            applicationName, feedbackRequestorDetails: requestorAppName && webhookEndpoint
                 ? {
                     requestorAppName,
                     requestorFeedbackEndpoint: webhookEndpoint,

package/lib/services/bigidProxyService.d.ts

@@ -8,7 +8,7 @@ export declare enum RequestMethod {
     DELETE = "delete"
 }
 export declare const getTenantRegistrations: (bigidToken: string) => Promise<TenantRegistration[]>;
-export declare const doCallToUrl: (bigidToken: string, requestMethod: RequestMethod, endpoint: string, bodyJson?: Record<string, any>) => Promise<any>;
+export declare const doCallToUrl: (bigidToken: string, requestMethod: RequestMethod, endpoint: string, bodyJson?: Record<string, any>, additionalHeaderFields?: Record<string, any>) => Promise<any>;
 /**
  * This method receives a message object to update BigID regarding the current state of the action execution
  * (should be used in case of an async actions)
@@ -22,23 +22,23 @@ export declare const updateActionStatusToBigID: (executionContext: ExecutionCont
  * @param endpoint - the endpoint in BigID, used for GET request. e.g - {BigIDBaseUrl}/ds_connections
  * @return - String containing the response from BigID
  */
-export declare const executeHttpGet: (executionContext: ExecutionContext, endpoint: string) => Promise<any>;
+export declare const executeHttpGet: (executionContext: ExecutionContext, endpoint: string, additionalHeaderFields?: Record<string, any>) => Promise<any>;
 /**
  * the endpoint in BigID, used for POST requests. e.g - {BigIDBaseUrl}/scan
  */
-export declare const executeHttpPost: (executionContext: ExecutionContext, endpoint: string, obj: any) => Promise<any>;
+export declare const executeHttpPost: (executionContext: ExecutionContext, endpoint: string, obj: any, additionalHeaderFields?: Record<string, any>) => Promise<any>;
 /**
  * the endpoint in BigID, used for POST requests. e.g - {BigIDBaseUrl}/scan
  */
-export declare const executeHttpPut: (executionContext: ExecutionContext, endpoint: string, obj: any) => Promise<any>;
+export declare const executeHttpPut: (executionContext: ExecutionContext, endpoint: string, obj: any, additionalHeaderFields?: Record<string, any>) => Promise<any>;
 /**
  * the endpoint in BigID, used for DELETE requests.
  */
-export declare const executeHttpDelete: (executionContext: ExecutionContext, endpoint: string) => Promise<any>;
-export declare const executePost: (requestMethod: RequestMethod, baseUrl: string | undefined, bodyJson: Record<string, any>) => Promise<any>;
+export declare const executeHttpDelete: (executionContext: ExecutionContext, endpoint: string, additionalHeaderFields?: Record<string, any>) => Promise<any>;
+export declare const executePost: (requestMethod: RequestMethod, baseUrl: string | undefined, bodyJson: Record<string, any>, additionalHeaderFields?: Record<string, any>) => Promise<any>;
 export declare const uploadAttachment: (executionContext: ExecutionContext, filePathToUpload: string) => Promise<import("axios").AxiosResponse<any, any>>;
 export declare const getAppStorage: (executionContext: ExecutionContext) => Promise<any>;
-export declare const getValueFromAppStorage: (executionContext: ExecutionContext, key: string) => Promise<string>;
+export declare const getValueFromAppStorage: (executionContext: ExecutionContext, key: string) => Promise<string | null>;
 export declare const deleteKeyFromAppStorage: (executionContext: ExecutionContext, key: string) => Promise<void>;
 export declare const sendBiEvent: (executionContext: ExecutionContext, eventType: string, data: Object) => Promise<any>;
 export declare const saveInStorage: (executionContext: ExecutionContext, keyToStore: any, valueToStore: any) => Promise<void>;

package/lib/services/bigidProxyService.js

@@ -31,14 +31,10 @@ const getTenantRegistrations = (bigidToken) => __awaiter(void 0, void 0, void 0,
     return tenants;
 });
 exports.getTenantRegistrations = getTenantRegistrations;
-const doCallToUrl = (bigidToken, requestMethod, endpoint, bodyJson) => __awaiter(void 0, void 0, void 0, function* () {
+const doCallToUrl = (bigidToken, requestMethod, endpoint, bodyJson, additionalHeaderFields) => __awaiter(void 0, void 0, void 0, function* () {
     (0, utils_1.logInfo)(`--> bigid-proxy::callBigIdApi: [${requestMethod}] endpoint: ${endpoint}`);
     try {
-        const headers = {
-            Accept: 'application/json, text/plain, */*',
-            'Content-Type': 'application/json',
-            Authorization: bigidToken,
-        };
+        const headers = Object.assign({ Accept: 'application/json, text/plain, */*', 'Content-Type': 'application/json', Authorization: bigidToken }, (additionalHeaderFields || {}));
         const parsedUrl = new URL(endpoint);
         parsedUrl.pathname = parsedUrl.pathname.replace(/\/+/g, '/');
         const requestObj = {
@@ -63,10 +59,10 @@ const doCallToUrl = (bigidToken, requestMethod, endpoint, bodyJson) => __awaiter
     }
 });
 exports.doCallToUrl = doCallToUrl;
-function callBigIdApi(executionContext, requestMethod, endpoint, bodyJson, useEndpointWithoutBigIdBasePath) {
+function callBigIdApi(executionContext, requestMethod, endpoint, options) {
     return __awaiter(this, void 0, void 0, function* () {
-        const url = useEndpointWithoutBigIdBasePath ? endpoint : executionContext.bigidBaseUrl + endpoint;
-        return yield (0, exports.doCallToUrl)(executionContext.bigidToken, requestMethod, url, bodyJson);
+        const url = (options === null || options === void 0 ? void 0 : options.useEndpointWithoutBigIdBasePath) ? endpoint : executionContext.bigidBaseUrl + endpoint;
+        return yield (0, exports.doCallToUrl)(executionContext.bigidToken, requestMethod, url, options === null || options === void 0 ? void 0 : options.bodyJson, options === null || options === void 0 ? void 0 : options.additionalHeaderFields);
     });
 }
 /**
@@ -76,7 +72,10 @@ function callBigIdApi(executionContext, requestMethod, endpoint, bodyJson, useEn
  * @param actionResponseDetails
  */
 const updateActionStatusToBigID = (executionContext, actionResponseDetails) => __awaiter(void 0, void 0, void 0, function* () {
-    return yield callBigIdApi(executionContext, RequestMethod.PUT, executionContext.updateResultCallback, actionResponseDetails, true);
+    return yield callBigIdApi(executionContext, RequestMethod.PUT, executionContext.updateResultCallback, {
+        bodyJson: actionResponseDetails,
+        useEndpointWithoutBigIdBasePath: true,
+    });
 });
 exports.updateActionStatusToBigID = updateActionStatusToBigID;
 /**
@@ -85,31 +84,28 @@ exports.updateActionStatusToBigID = updateActionStatusToBigID;
  * @param endpoint - the endpoint in BigID, used for GET request. e.g - {BigIDBaseUrl}/ds_connections
  * @return - String containing the response from BigID
  */
-const executeHttpGet = (executionContext, endpoint) => __awaiter(void 0, void 0, void 0, function* () { return yield callBigIdApi(executionContext, RequestMethod.GET, endpoint); });
+const executeHttpGet = (executionContext, endpoint, additionalHeaderFields) => __awaiter(void 0, void 0, void 0, function* () { return yield callBigIdApi(executionContext, RequestMethod.GET, endpoint, { additionalHeaderFields }); });
 exports.executeHttpGet = executeHttpGet;
 /**
  * the endpoint in BigID, used for POST requests. e.g - {BigIDBaseUrl}/scan
  */
-const executeHttpPost = (executionContext, endpoint, obj) => __awaiter(void 0, void 0, void 0, function* () { return yield callBigIdApi(executionContext, RequestMethod.POST, endpoint, obj); });
+const executeHttpPost = (executionContext, endpoint, obj, additionalHeaderFields) => __awaiter(void 0, void 0, void 0, function* () { return yield callBigIdApi(executionContext, RequestMethod.POST, endpoint, { bodyJson: obj, additionalHeaderFields }); });
 exports.executeHttpPost = executeHttpPost;
 /**
  * the endpoint in BigID, used for POST requests. e.g - {BigIDBaseUrl}/scan
  */
-const executeHttpPut = (executionContext, endpoint, obj) => __awaiter(void 0, void 0, void 0, function* () { return yield callBigIdApi(executionContext, RequestMethod.PUT, endpoint, obj); });
+const executeHttpPut = (executionContext, endpoint, obj, additionalHeaderFields) => __awaiter(void 0, void 0, void 0, function* () { return yield callBigIdApi(executionContext, RequestMethod.PUT, endpoint, { bodyJson: obj, additionalHeaderFields }); });
 exports.executeHttpPut = executeHttpPut;
 /**
  * the endpoint in BigID, used for DELETE requests.
  */
-const executeHttpDelete = (executionContext, endpoint) => __awaiter(void 0, void 0, void 0, function* () { return yield callBigIdApi(executionContext, RequestMethod.DELETE, endpoint); });
+const executeHttpDelete = (executionContext, endpoint, additionalHeaderFields) => __awaiter(void 0, void 0, void 0, function* () { return yield callBigIdApi(executionContext, RequestMethod.DELETE, endpoint, { additionalHeaderFields }); });
 exports.executeHttpDelete = executeHttpDelete;
-const executePost = (requestMethod, baseUrl, bodyJson) => __awaiter(void 0, void 0, void 0, function* () {
+const executePost = (requestMethod, baseUrl, bodyJson, additionalHeaderFields) => __awaiter(void 0, void 0, void 0, function* () {
     var _a, _b, _c, _d, _e, _f;
     try {
         const url = baseUrl + 'api/v1/sessions';
-        const headers = {
-            Accept: 'application/json',
-            'Content-type': 'application/json',
-        };
+        const headers = Object.assign({ Accept: 'application/json', 'Content-type': 'application/json' }, (additionalHeaderFields || {}));
         const requestObj = {
             method: requestMethod,
             url: url,

package/log/app.log

@@ -0,0 +1,8 @@
+[2025-04-23T11:04:36.805] [INFO] default - --> bigid-proxy::callBigIdApi: [get] endpoint: https://bigid-ui:9090/api/v1/id_connections
+[2025-04-23T11:04:36.819] [INFO] default - <-- bigid-proxy::callBigIdApi: https://bigid-ui:9090/api/v1/id_connections success
+[2025-04-23T11:04:36.822] [INFO] default - --> bigid-proxy::callBigIdApi: [post] endpoint: https://bigid-ui:9090/api/v1/id_connections
+[2025-04-23T11:04:36.826] [INFO] default - <-- bigid-proxy::callBigIdApi: https://bigid-ui:9090/api/v1/id_connections success
+[2025-04-23T11:04:36.827] [INFO] default - --> bigid-proxy::callBigIdApi: [put] endpoint: https://bigid-ui:9090/api/v1/id_connections
+[2025-04-23T11:04:36.831] [INFO] default - <-- bigid-proxy::callBigIdApi: https://bigid-ui:9090/api/v1/id_connections success
+[2025-04-23T11:04:36.832] [INFO] default - --> bigid-proxy::callBigIdApi: [delete] endpoint: https://bigid-ui:9090/api/v1/id_connections
+[2025-04-23T11:04:36.834] [INFO] default - <-- bigid-proxy::callBigIdApi: https://bigid-ui:9090/api/v1/id_connections success

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@bigid/apps-infrastructure-node-js",
-  "version": "1.218.1",
+  "version": "1.226.1",
   "description": "",
   "main": "lib/index.js",
   "scripts": {
     "docs": "npx tsc && ./node_modules/.bin/jsdoc -c jsdoc.json",
-    "test": "mocha 'test/**/*.ts'"
+    "test": "mocha --require ts-node/register --require source-map-support/register 'test/**/*.ts'"
   },
   "types": "lib/index.d.ts",
   "repository": {
@@ -15,18 +15,22 @@
   "author": "Shay Sheli",
   "homepage": "https://github.com/bigexchange/apps-infrastructure-node-js#readme",
   "devDependencies": {
+    "@types/chai": "^4.3.20",
     "@types/express": "^4.17.13",
     "@types/http-errors": "^1.8.1",
     "@types/mocha": "10.0.3",
+    "@types/nock": "^11.1.0",
     "@types/node": "^16.11.10",
     "@types/node-schedule": "^2.1.0",
     "@typescript-eslint/eslint-plugin": "4.6.1",
     "@typescript-eslint/parser": "4.6.1",
+    "chai": "4.5.0",
     "eslint": "7.12.1",
     "eslint-config-prettier": "^6.15.0",
     "eslint-plugin-no-only-tests": "2.4.0",
     "eslint-plugin-prettier": "^3.1.4",
     "jsdoc": "4.0.2",
+    "nock": "^13.5.6",
     "prettier": "^2.4.1",
     "typescript": "^4.5.2"
   },

package/src/services/actionsHubService.ts

@@ -42,6 +42,7 @@ export const getCommandsRegistrations = async (accessToken?: string): Promise<Co
  *
  * @param {string} actionName - the action name to be executed.
  * @param {string} command    - the command to be executed.
+ * @param {string} applicationName - the application name that the command to be triggered belongs to
  * @param {string} requestorAppName - the app name of the execution requestor.
  * @param {string} webhookEndpoint - the endpoint of the requestor app to receive execution status messages.
  * @param {Record<string, any>} params - the relevant params of the action to be executed.
@@ -51,6 +52,7 @@ export const getCommandsRegistrations = async (accessToken?: string): Promise<Co
 export const executeCommand = async (
   actionName: string,
   command: string,
+  applicationName?: string,
   requestorAppName?: string,
   webhookEndpoint?: string,
   params?: Record<string, any>[],
@@ -67,6 +69,7 @@ export const executeCommand = async (
       {
         actionName,
         command,
+        applicationName,
         feedbackRequestorDetails:
           requestorAppName && webhookEndpoint
             ? {

package/src/services/bigidProxyService.ts

@@ -15,6 +15,12 @@ export enum RequestMethod {
   DELETE = 'delete',
 }
 
+interface BigIdApiRequestOptions {
+  bodyJson?: ActionResponseDetails;
+  useEndpointWithoutBigIdBasePath?: boolean;
+  additionalHeaderFields?: Record<string, any>;
+}
+
 export const getTenantRegistrations = async (bigidToken: string): Promise<TenantRegistration[]> => {
   const {
     data: {
@@ -32,6 +38,7 @@ export const doCallToUrl = async (
   requestMethod: RequestMethod,
   endpoint: string,
   bodyJson?: Record<string, any>,
+  additionalHeaderFields?: Record<string, any>,
 ) => {
   logInfo(`--> bigid-proxy::callBigIdApi: [${requestMethod}] endpoint: ${endpoint}`);
   try {
@@ -39,6 +46,7 @@ export const doCallToUrl = async (
       Accept: 'application/json, text/plain, */*',
       'Content-Type': 'application/json',
       Authorization: bigidToken,
+      ...(additionalHeaderFields || {}),
     };
     const parsedUrl = new URL(endpoint);
     parsedUrl.pathname = parsedUrl.pathname.replace(/\/+/g, '/');
@@ -71,11 +79,16 @@ async function callBigIdApi(
   executionContext: ExecutionContext,
   requestMethod: RequestMethod,
   endpoint: string,
-  bodyJson?: ActionResponseDetails,
-  useEndpointWithoutBigIdBasePath?: boolean,
+  options: BigIdApiRequestOptions,
 ) {
-  const url = useEndpointWithoutBigIdBasePath ? endpoint : executionContext.bigidBaseUrl + endpoint;
-  return await doCallToUrl(executionContext.bigidToken, requestMethod, url, bodyJson);
+  const url = options?.useEndpointWithoutBigIdBasePath ? endpoint : executionContext.bigidBaseUrl + endpoint;
+  return await doCallToUrl(
+    executionContext.bigidToken,
+    requestMethod,
+    url,
+    options?.bodyJson,
+    options?.additionalHeaderFields,
+  );
 }
 
 /**
@@ -88,13 +101,10 @@ export const updateActionStatusToBigID = async (
   executionContext: ExecutionContext,
   actionResponseDetails: ActionResponseDetails,
 ) =>
-  await callBigIdApi(
-    executionContext,
-    RequestMethod.PUT,
-    executionContext.updateResultCallback,
-    actionResponseDetails,
-    true,
-  );
+  await callBigIdApi(executionContext, RequestMethod.PUT, executionContext.updateResultCallback, {
+    bodyJson: actionResponseDetails,
+    useEndpointWithoutBigIdBasePath: true,
+  });
 
 /**
  *
@@ -102,37 +112,53 @@ export const updateActionStatusToBigID = async (
  * @param endpoint - the endpoint in BigID, used for GET request. e.g - {BigIDBaseUrl}/ds_connections
  * @return - String containing the response from BigID
  */
-export const executeHttpGet = async (executionContext: ExecutionContext, endpoint: string) =>
-  await callBigIdApi(executionContext, RequestMethod.GET, endpoint);
+export const executeHttpGet = async (
+  executionContext: ExecutionContext,
+  endpoint: string,
+  additionalHeaderFields?: Record<string, any>,
+) => await callBigIdApi(executionContext, RequestMethod.GET, endpoint, { additionalHeaderFields });
 
 /**
  * the endpoint in BigID, used for POST requests. e.g - {BigIDBaseUrl}/scan
  */
-export const executeHttpPost = async (executionContext: ExecutionContext, endpoint: string, obj: any) =>
-  await callBigIdApi(executionContext, RequestMethod.POST, endpoint, obj);
+export const executeHttpPost = async (
+  executionContext: ExecutionContext,
+  endpoint: string,
+  obj: any,
+  additionalHeaderFields?: Record<string, any>,
+) => await callBigIdApi(executionContext, RequestMethod.POST, endpoint, { bodyJson: obj, additionalHeaderFields });
 
 /**
  * the endpoint in BigID, used for POST requests. e.g - {BigIDBaseUrl}/scan
  */
-export const executeHttpPut = async (executionContext: ExecutionContext, endpoint: string, obj: any) =>
-  await callBigIdApi(executionContext, RequestMethod.PUT, endpoint, obj);
+export const executeHttpPut = async (
+  executionContext: ExecutionContext,
+  endpoint: string,
+  obj: any,
+  additionalHeaderFields?: Record<string, any>,
+) => await callBigIdApi(executionContext, RequestMethod.PUT, endpoint, { bodyJson: obj, additionalHeaderFields });
 
 /**
  * the endpoint in BigID, used for DELETE requests.
  */
-export const executeHttpDelete = async (executionContext: ExecutionContext, endpoint: string) =>
-  await callBigIdApi(executionContext, RequestMethod.DELETE, endpoint);
+export const executeHttpDelete = async (
+  executionContext: ExecutionContext,
+  endpoint: string,
+  additionalHeaderFields?: Record<string, any>,
+) => await callBigIdApi(executionContext, RequestMethod.DELETE, endpoint, { additionalHeaderFields });
 
 export const executePost = async (
   requestMethod: RequestMethod,
   baseUrl: string | undefined,
   bodyJson: Record<string, any>,
+  additionalHeaderFields?: Record<string, any>,
 ) => {
   try {
     const url = baseUrl + 'api/v1/sessions';
     const headers = {
       Accept: 'application/json',
       'Content-type': 'application/json',
+      ...(additionalHeaderFields || {}),
     };
     const requestObj: Record<string, any> = {
       method: requestMethod,
@@ -177,7 +203,10 @@ export const uploadAttachment = (executionContext: ExecutionContext, filePathToU
 export const getAppStorage = (executionContext: ExecutionContext) =>
   executeHttpGet(executionContext, `tpa/${executionContext.tpaId}/storage`);
 
-export const getValueFromAppStorage = async (executionContext: ExecutionContext, key: string): Promise<string> => {
+export const getValueFromAppStorage = async (
+  executionContext: ExecutionContext,
+  key: string,
+): Promise<string | null> => {
   const { data } = await executeHttpGet(executionContext, `tpa/${executionContext.tpaId}/storage/key/${key}`);
   return data === 'Key not found' ? null : data?.value;
 };

package/test/mock.ts

@@ -0,0 +1,31 @@
+export const mockExecutionContext = {
+  actionName: 'helloWorld',
+  executionId: '6787da8066db56a1866ccb82',
+  presetId: '6787d2a566db56a1866c8ea7',
+  globalParams: [
+    {
+      paramName: 'username',
+      paramValue: 'admin',
+    },
+    {
+      paramName: 'password',
+      paramValue: 'admin',
+    },
+  ],
+  actionParams: [
+    {
+      paramName: 'idConnectionName',
+      paramValue: 'identity source',
+    },
+  ],
+  bigidToken:
+    'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VyX25hbWUiOiJiaWdpZC13ZWIiLCJpc0FkbWluIjp0cnVlLCJyb2xlSWRzIjpbInN5c3RlbSJdLCJ0eXBlIjoiYWNjZXNzLXRva2VuIiwidGVuYW50SWQiOiJTSU5HTEVfVEVOQU5UIiwiaWF0IjoxNzM2OTU2NTQ0LCJleHAiOjE3Mzc1NjEzNDR9.jlcHlT8uKxHA615NGAxIsM8-Cgvda3aOuy2Lji_u5hk',
+  updateResultCallback: 'https://bigid-ui:9090/api/v1/tpa/executions/6787da8066db56a1866ccb82',
+  bigidBaseUrl: 'https://bigid-ui:9090/api/v1/',
+  tpaId: '6787d2a566db56a1866c8e9d',
+  tpaName: 'Basic demo Nodejs app',
+};
+
+export const mockBaseUrl = 'https://bigid-ui:9090/api/v1';
+
+export const mockDataResponse = { Response: 'ok' };

package/test/unit/api/requests.spec.ts

@@ -0,0 +1,44 @@
+import { expect } from 'chai';
+import nock = require("nock");
+import {
+  executeHttpGet,
+  executeHttpPost,
+  executeHttpPut,
+  executeHttpDelete,
+} from '../../../src/services/bigidProxyService';
+import { mockExecutionContext, mockBaseUrl, mockDataResponse } from '../../mock';
+
+describe('Main api requests unit tests', () => {
+  const apiUrl = 'id_connections';
+  const modifiedHeader = { AdditionalFieldName: 'AdditionalFieldValue' };
+  const expectedFieldName = 'AdditionalFieldName';
+  const expectedFieldValue = 'AdditionalFieldValue';
+
+  afterEach(() => {
+    nock.cleanAll();
+  });
+
+  it('Should verify modified header for executeHttpGet request', async () => {
+    nock(mockBaseUrl).get(`/${apiUrl}`).matchHeader(expectedFieldName,expectedFieldValue).reply(200, mockDataResponse);
+    const response = await executeHttpGet(mockExecutionContext, apiUrl, modifiedHeader);
+    expect(response.data).to.deep.equal(mockDataResponse);
+  });
+
+  it('Should verify modified header for executeHttpPost request', async () => {
+    nock(mockBaseUrl).post(`/${apiUrl}`).matchHeader(expectedFieldName,expectedFieldValue).reply(200, mockDataResponse);
+    const response = await executeHttpPost(mockExecutionContext, apiUrl, undefined, modifiedHeader);
+    expect(response.data).to.deep.equal(mockDataResponse);
+  });
+
+  it('Should verify modified header for executeHttpPut request', async () => {
+    nock(mockBaseUrl).put(`/${apiUrl}`).matchHeader(expectedFieldName,expectedFieldValue).reply(200, mockDataResponse);
+    const response = await executeHttpPut(mockExecutionContext, apiUrl, undefined, modifiedHeader);
+    expect(response.data).to.deep.equal(mockDataResponse);
+  });
+
+  it('Should verify modified header for executeHttpDelete request', async () => {
+    nock(mockBaseUrl).delete(`/${apiUrl}`).matchHeader(expectedFieldName,expectedFieldValue).reply(200, mockDataResponse);
+    const response = await executeHttpDelete(mockExecutionContext, apiUrl, modifiedHeader);
+    expect(response.data).to.deep.equal(mockDataResponse);
+  });
+});