@reltio/components 1.4.1876 → 1.4.1877

package/esm/hooks/useAPI/useAPI.test.js

@@ -0,0 +1,1398 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import React, { useState } from 'react';
+import { renderHook, act } from '@testing-library/react-hooks';
+import { CustomAction, CustomScriptPlatform, initializeWebWorker, RequestAction, Mode } from '@reltio/mdm-sdk';
+import * as request from '@reltio/mdm-sdk/src/network';
+import { useHtmlSanitizer } from '../useHtmlSanitizer';
+import { useWorkflowCheckPermission } from '../../features/workflow/hooks/useWorkflowCheckPermission';
+import { SandboxAPIContext } from '../../contexts/SandboxAPIContext';
+import { InterceptHandlersContext } from '../../contexts/InterceptHandlersContext';
+import { SnackbarContext } from '../../contexts/SnackbarContext';
+import { MdmModuleProvider } from '../../contexts/MdmModuleContext';
+import { createConfig } from './config.test-data';
+import { useAPI } from '../useAPI';
+jest.mock('@reltio/mdm-sdk', function () { return (__assign(__assign({}, jest.requireActual('@reltio/mdm-sdk')), { initializeWebWorker: jest.fn() })); });
+jest.mock('../useHtmlSanitizer', function () { return ({
+    useHtmlSanitizer: jest.fn()
+}); });
+jest.mock('../../features/workflow/hooks/useWorkflowCheckPermission', function () { return ({
+    useWorkflowCheckPermission: jest.fn().mockReturnValue(true)
+}); });
+var tenant = { id: 'alenat', name: 'alenat' };
+var uiPath = "https://tst-01.reltio.com/nui/".concat(tenant.id, "/");
+var metadata = {
+    uri: 'configuration',
+    entityTypes: [
+        {
+            uri: 'configuration/entityTypes/HCA',
+            attributes: [],
+            analyticsAttributes: []
+        },
+        {
+            uri: 'configuration/entityTypes/HCP',
+            attributes: [],
+            analyticsAttributes: []
+        }
+    ],
+    relationTypes: []
+};
+var entity = { uri: 'entities/mnGg0XB', type: 'configuration/entityTypes/HCA', attributes: {} };
+var apiPath = '/nui/reltioAPI';
+var servicesPath = 'https://tst-01.reltio.com/nui/services';
+var reltioPath = 'https://tst-01.reltio.com/reltio';
+var workflowPath = 'https://tst-01-workflow.reltio.com/workflow-adapter';
+var user = { username: 'alexey.starodubtsev' };
+var searchProviderData = { type: 'search', data: { query: 'some search' } };
+var defaultMdmValues = {
+    tenant: tenant,
+    uiPath: uiPath,
+    metadata: metadata,
+    entity: entity,
+    apiPath: apiPath,
+    servicesPath: servicesPath,
+    reltioPath: reltioPath,
+    workflowPath: workflowPath,
+    user: user,
+    searchProviderData: searchProviderData,
+    mode: Mode.Viewing
+};
+var mdmActions = { openSearch: jest.fn() };
+var createInterceptors = function () { return ({
+    addInternalRequestInterceptor: jest.fn(),
+    addInternalResponseInterceptor: jest.fn(),
+    removeInternalRequestInterceptor: jest.fn(),
+    removeInternalResponseInterceptor: jest.fn(),
+    startInterceptorInit: jest.fn(),
+    finishInterceptorInit: jest.fn()
+}); };
+var interceptors = createInterceptors();
+var showSnackbarMessage = jest.fn();
+var sandbox = {
+    getCurrentPerspectiveId: jest.fn().mockReturnValue('23'),
+    showPerspective: jest.fn(),
+    setEntityUri: jest.fn().mockImplementation(function (entityUri, listener) { return setTimeout(listener, 1000); })
+};
+var setUp = function (_a) {
+    var _b = _a === void 0 ? {} : _a, _c = _b.config, config = _c === void 0 ? createConfig() : _c, _d = _b.mdmValues, mdmValues = _d === void 0 ? defaultMdmValues : _d;
+    var updateMdmValues;
+    var Providers = function (_a) {
+        var children = _a.children;
+        var _b = useState(mdmValues), mdmValuesState = _b[0], setMdmValuesState = _b[1];
+        updateMdmValues = setMdmValuesState;
+        return (React.createElement(MdmModuleProvider, { values: mdmValuesState, actions: mdmActions },
+            React.createElement(SnackbarContext.Provider, { value: showSnackbarMessage },
+                React.createElement(SandboxAPIContext.Provider, { value: sandbox },
+                    React.createElement(InterceptHandlersContext.Provider, { value: interceptors }, children)))));
+    };
+    return __assign(__assign({}, renderHook(useAPI, { initialProps: config, wrapper: Providers })), { updateMdmValues: updateMdmValues });
+};
+describe('useAPI custom sandbox behavior', function () {
+    var postMessage = jest.fn();
+    var worker = {
+        postMessage: postMessage,
+        terminate: jest.fn(),
+        onmessageerror: jest.fn(),
+        onerror: jest.fn(),
+        onmessage: jest.fn(),
+        dispatchEvent: jest.fn(),
+        addEventListener: jest.fn(),
+        removeEventListener: jest.fn()
+    };
+    var htmlSanitizer = jest.fn().mockImplementation(function (html) { return html; });
+    var onmessageFromWorker;
+    var requestMock = jest.spyOn(request, 'rawRequest');
+    beforeEach(function () {
+        jest.clearAllMocks();
+        useHtmlSanitizer.mockImplementation(function () { return htmlSanitizer; });
+        initializeWebWorker.mockImplementation(function (workerUrl, process) {
+            onmessageFromWorker = function (task) { return process({ task: task, worker: worker }); };
+            return worker;
+        });
+    });
+    it('should return html on event setHtml', function () {
+        var result = setUp().result;
+        var html = '<div id="testId">something</div>';
+        var htmlBlock = document.createElement('div');
+        document.body.appendChild(htmlBlock);
+        htmlBlock.innerHTML = html;
+        var child = '<p>test</p>';
+        var childHtml = "<div id=\"testId\">".concat(child, "</div>");
+        var childHtmlBlock = document.createElement('div');
+        childHtmlBlock.innerHTML = childHtml;
+        expect(result.current).toMatchObject({
+            html: undefined,
+            visible: true,
+            tooltip: null,
+            customStyles: {}
+        });
+        act(function () {
+            onmessageFromWorker({ action: CustomAction.SET_HTML, params: { html: html } });
+        });
+        expect(htmlSanitizer).toBeCalledWith(html);
+        expect(result.current.html).toEqual(htmlBlock);
+        act(function () {
+            onmessageFromWorker({ action: CustomAction.SET_HTML, params: { html: child, id: 'testId' } });
+        });
+        expect(document.body.childNodes[0]).toEqual(childHtmlBlock);
+    });
+    it('should allow disabled and checked state for checkbox', function () {
+        var _a;
+        var html = '<table><tbody><tr><td>Checked:</td><td>UnChecked_enabled: <input type="checkbox" id="myCheck1"></td><td>Checked_disabled: <input type="checkbox" id="myCheck2" checked="true" disabled="true"></td></tr></tbody></table>';
+        var result = setUp().result;
+        act(function () {
+            onmessageFromWorker({ action: CustomAction.SET_HTML, params: { html: html } });
+        });
+        expect((_a = result.current.html) === null || _a === void 0 ? void 0 : _a.innerHTML).toMatch(html);
+    });
+    it('should not fail on setHtml event with wrong id', function () {
+        var result = setUp().result;
+        var html = '<div>something</div>';
+        act(function () {
+            onmessageFromWorker({ action: CustomAction.SET_HTML, params: { html: html, id: 'nonExist' } });
+        });
+        expect(htmlSanitizer).toBeCalledWith(html);
+        expect(result.current.html).toEqual(undefined);
+    });
+    it('should return popup on event showPopup', function () {
+        var result = setUp().result;
+        var popup = '<div>something</div>';
+        var popupBlock = document.createElement('div');
+        popupBlock.innerHTML = popup;
+        expect(result.current.popup).toBe(undefined);
+        act(function () {
+            onmessageFromWorker({ action: CustomAction.SHOW_POPUP, params: popup });
+        });
+        expect(htmlSanitizer).toBeCalledWith(popup);
+        expect(result.current.popup).toEqual(popupBlock);
+    });
+    it('should return null popup on event hidePopup', function () {
+        var result = setUp().result;
+        var popup = '<div>something</div>';
+        act(function () {
+            onmessageFromWorker({ action: CustomAction.SHOW_POPUP, params: popup });
+        });
+        expect(result.current.popup).not.toEqual(null);
+        act(function () {
+            onmessageFromWorker({ action: CustomAction.HIDE_POPUP, params: {} });
+        });
+        expect(result.current.popup).toEqual(null);
+    });
+    it('should change visible props on setVisibility event', function () {
+        var result = setUp().result;
+        var html = '<div>something</div>';
+        act(function () {
+            onmessageFromWorker({ action: CustomAction.SET_HTML, params: { html: html } });
+        });
+        var htmlBlock = document.createElement('div');
+        htmlBlock.innerHTML = html;
+        expect(result.current.html).toEqual(htmlBlock);
+        expect(result.current.visible).toBe(true);
+        act(function () {
+            onmessageFromWorker({ action: CustomAction.SET_VISIBILITY, params: 'hidden' });
+        });
+        expect(result.current.visible).toBe(false);
+        act(function () {
+            onmessageFromWorker({ action: CustomAction.SET_VISIBILITY, params: 'visible' });
+        });
+        expect(result.current.html).toEqual(htmlBlock);
+        expect(result.current.visible).toBe(true);
+    });
+    it('should call console.log on log event', function () {
+        setUp();
+        var message = 'some data to console';
+        var log = jest.spyOn(console, 'log');
+        act(function () {
+            onmessageFromWorker({ action: CustomAction.LOG, params: message });
+        });
+        expect(log).toHaveBeenCalledWith(message);
+        expect(log).toHaveBeenCalledTimes(1);
+    });
+    it('should change tooltip props on setToolTip event', function () {
+        var result = setUp().result;
+        var html = '<div>something</div>';
+        act(function () {
+            onmessageFromWorker({ action: CustomAction.SET_HTML, params: { html: html } });
+        });
+        var htmlBlock = document.createElement('div');
+        htmlBlock.innerHTML = html;
+        expect(result.current.html).toEqual(htmlBlock);
+        expect(result.current.tooltip).toBeNull();
+        var tooltip = 'Tooltip value';
+        act(function () {
+            onmessageFromWorker({ action: CustomAction.SET_TOOLTIP, params: tooltip });
+        });
+        expect(result.current.tooltip).toBe(tooltip);
+        expect(result.current.html).toEqual(htmlBlock);
+    });
+    it('should change styles on setHeight, setWidth, setEnabled', function () {
+        var result = setUp().result;
+        var html = '<div>something</div>';
+        act(function () {
+            onmessageFromWorker({ action: CustomAction.SET_HTML, params: { html: html } });
+        });
+        var htmlBlock = document.createElement('div');
+        htmlBlock.innerHTML = html;
+        expect(result.current.html).toEqual(htmlBlock);
+        expect(result.current.customStyles).toEqual({});
+        var height = '200px';
+        act(function () {
+            onmessageFromWorker({ action: CustomAction.SET_HEIGHT, params: height });
+        });
+        expect(result.current.customStyles).toEqual({ height: height });
+        expect(result.current.html).toEqual(htmlBlock);
+        var width = '400px';
+        act(function () {
+            onmessageFromWorker({ action: CustomAction.SET_WIDTH, params: width });
+        });
+        expect(result.current.customStyles).toEqual({ height: height, width: width });
+        expect(result.current.html).toEqual(htmlBlock);
+        act(function () {
+            onmessageFromWorker({ action: CustomAction.SET_ENABLED, params: false });
+        });
+        expect(result.current.customStyles).toEqual({ height: height, width: width, 'pointer-events': 'none' });
+        expect(result.current.html).toEqual(htmlBlock);
+        act(function () {
+            onmessageFromWorker({ action: CustomAction.SET_ENABLED, params: true });
+        });
+        expect(result.current.customStyles).toEqual({ height: height, width: width });
+        expect(result.current.html).toEqual(htmlBlock);
+    });
+    it('should set message on message event and clean on close popup', function () {
+        setUp();
+        var message = 'hello';
+        act(function () {
+            onmessageFromWorker({ action: CustomAction.MESSAGE, params: message });
+        });
+        expect(showSnackbarMessage).toBeCalledWith(message);
+    });
+    it('should not send api request on action request and name api if url is empty', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var waitFor, result, params;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    waitFor = setUp().waitFor;
+                    result = { errorMessage: 'URL is empty' };
+                    params = {
+                        name: RequestAction.API,
+                        id: '1',
+                        headers: {
+                            'Content-Type': 'application/json'
+                        }
+                    };
+                    act(function () {
+                        onmessageFromWorker({ action: CustomAction.REQUEST, params: params });
+                    });
+                    return [4 /*yield*/, waitFor(function () {
+                            return expect(postMessage).toHaveBeenCalledWith(__assign({ action: 'response', result: { data: result, headers: params.headers, status: 0 } }, params));
+                        })];
+                case 1:
+                    _a.sent();
+                    expect(requestMock).not.toHaveBeenCalled();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should not send api request on action request and name api if no permissions', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var config, waitFor, result, params;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    config = createConfig({ permissions: ['/tenant'] });
+                    waitFor = setUp({ config: config }).waitFor;
+                    result = { errorMessage: 'Not enough permissions' };
+                    params = {
+                        name: RequestAction.API,
+                        id: '1',
+                        url: '/entity',
+                        headers: {
+                            'Content-Type': 'application/json'
+                        }
+                    };
+                    act(function () {
+                        onmessageFromWorker({ action: CustomAction.REQUEST, params: params });
+                    });
+                    return [4 /*yield*/, waitFor(function () {
+                            return expect(postMessage).toHaveBeenCalledWith(__assign(__assign({ action: 'response', result: { data: result, headers: params.headers, status: 0 }, validationUrl: params.url }, params), { url: '/nui/reltioAPI/api/alenat/entity' }));
+                        })];
+                case 1:
+                    _a.sent();
+                    expect(requestMock).not.toHaveBeenCalled();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should send api request on action request and name api', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var result, config, waitFor, params;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    result = { success: 'message' };
+                    requestMock.mockResolvedValue(result);
+                    config = createConfig({ permissions: ['https://reltio.com'] });
+                    waitFor = setUp({ config: config }).waitFor;
+                    params = {
+                        name: RequestAction.API,
+                        id: '1',
+                        url: 'https://reltio.com/entity',
+                        headers: {
+                            'Content-Type': 'application/json'
+                        }
+                    };
+                    act(function () {
+                        onmessageFromWorker({ action: CustomAction.REQUEST, params: params });
+                    });
+                    return [4 /*yield*/, waitFor(function () {
+                            return expect(postMessage).toHaveBeenCalledWith(__assign({ action: 'response', result: { data: result, headers: params.headers, status: 200 }, validationUrl: params.url }, params));
+                        })];
+                case 1:
+                    _a.sent();
+                    expect(requestMock).toHaveBeenCalledWith(params.url, {
+                        method: 'GET',
+                        headers: {
+                            'Content-Type': 'application/json'
+                        },
+                        noRequestProcessor: true,
+                        noRetry: true
+                    });
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should send api request with access token', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var result, mdmValues, config, waitFor, params;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    result = { success: 'message' };
+                    requestMock.mockImplementation(function (url, _options) {
+                        var isTokenRequest = url.includes('getTokenForWorker');
+                        return Promise.resolve(isTokenRequest ? { accessToken: 'some token' } : result);
+                    });
+                    mdmValues = __assign(__assign({}, defaultMdmValues), { servicesPath: '/nui/services' });
+                    config = createConfig({ permissions: ['https://reltio.com'] });
+                    waitFor = setUp({ mdmValues: mdmValues, config: config }).waitFor;
+                    params = {
+                        name: RequestAction.API,
+                        id: '1',
+                        url: 'https://reltio.com/entity',
+                        headers: {
+                            'Content-Type': 'application/json'
+                        }
+                    };
+                    act(function () {
+                        onmessageFromWorker({ action: CustomAction.REQUEST, params: params });
+                    });
+                    return [4 /*yield*/, waitFor(function () {
+                            return expect(postMessage).toHaveBeenCalledWith(__assign({ action: 'response', result: { data: result, headers: params.headers, status: 200 }, validationUrl: params.url }, params));
+                        })];
+                case 1:
+                    _a.sent();
+                    expect(requestMock).toHaveBeenCalledWith(params.url, {
+                        method: 'GET',
+                        headers: {
+                            'Content-Type': 'application/json',
+                            Authorization: 'Bearer some token'
+                        },
+                        noRequestProcessor: true,
+                        noRetry: true
+                    });
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should send api request on action request and name api and handle errors properly', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var config, waitFor, params;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    requestMock.mockImplementation(function (url, _options) {
+                        var isTokenRequest = url.includes('getTokenForWorker');
+                        return isTokenRequest
+                            ? Promise.resolve({ accessToken: 'some token' })
+                            : Promise.reject({ error: '{"message": "some error"}' });
+                    });
+                    config = createConfig({ permissions: ['https://reltio.com'] });
+                    waitFor = setUp({ config: config }).waitFor;
+                    params = {
+                        name: RequestAction.API,
+                        id: '1',
+                        url: 'https://reltio.com/entity',
+                        headers: {
+                            'Content-Type': 'application/json'
+                        }
+                    };
+                    act(function () {
+                        onmessageFromWorker({ action: CustomAction.REQUEST, params: params });
+                    });
+                    return [4 /*yield*/, waitFor(function () {
+                            return expect(postMessage).toHaveBeenCalledWith(__assign({ action: 'response', result: {
+                                    data: {
+                                        error: '{"message": "some error"}'
+                                    },
+                                    headers: params.headers,
+                                    status: 0
+                                }, validationUrl: params.url }, params));
+                        })];
+                case 1:
+                    _a.sent();
+                    expect(requestMock).toHaveBeenCalledWith(params.url, {
+                        method: 'GET',
+                        headers: {
+                            'Content-Type': 'application/json',
+                            Authorization: 'Bearer some token'
+                        },
+                        noRequestProcessor: true,
+                        noRetry: true
+                    });
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should not send workflow request on action request and name workflow if url is empty', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var waitFor, result, params;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    waitFor = setUp().waitFor;
+                    result = { errorMessage: 'URL is empty' };
+                    params = {
+                        name: RequestAction.WORKFLOW,
+                        id: '1',
+                        headers: {
+                            'Content-Type': 'application/json'
+                        }
+                    };
+                    act(function () {
+                        onmessageFromWorker({ action: CustomAction.REQUEST, params: params });
+                    });
+                    return [4 /*yield*/, waitFor(function () {
+                            return expect(postMessage).toHaveBeenCalledWith(__assign({ action: 'response', result: { data: result, headers: params.headers, status: 200 } }, params));
+                        })];
+                case 1:
+                    _a.sent();
+                    expect(requestMock).not.toHaveBeenCalled();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should not send api request on action request and name workflow if no permissions', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var config, waitFor, result, params;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    config = createConfig({ permissions: ['/tenant'] });
+                    waitFor = setUp({ config: config }).waitFor;
+                    result = { errorMessage: 'Not enough permissions' };
+                    params = {
+                        name: RequestAction.WORKFLOW,
+                        id: '1',
+                        url: '/entity',
+                        headers: {
+                            'Content-Type': 'application/json'
+                        }
+                    };
+                    act(function () {
+                        onmessageFromWorker({ action: CustomAction.REQUEST, params: params });
+                    });
+                    return [4 /*yield*/, waitFor(function () {
+                            return expect(postMessage).toHaveBeenCalledWith(__assign({ action: 'response', result: { data: result, headers: params.headers, status: 200 }, validationUrl: params.url }, params));
+                        })];
+                case 1:
+                    _a.sent();
+                    expect(requestMock).not.toHaveBeenCalled();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should not send api request on action request and name workflow if no workflowPath', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mdmValues, config, waitFor, result, params;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mdmValues = __assign(__assign({}, defaultMdmValues), { workflowPath: undefined });
+                    config = createConfig({ permissions: ['/entity'] });
+                    waitFor = setUp({ mdmValues: mdmValues, config: config }).waitFor;
+                    result = { errorMessage: 'Workflow path is not defined' };
+                    params = {
+                        name: RequestAction.WORKFLOW,
+                        id: '1',
+                        url: '/entity',
+                        headers: {
+                            'Content-Type': 'application/json'
+                        }
+                    };
+                    act(function () {
+                        onmessageFromWorker({ action: CustomAction.REQUEST, params: params });
+                    });
+                    return [4 /*yield*/, waitFor(function () {
+                            return expect(postMessage).toHaveBeenCalledWith(__assign({ action: 'response', result: { data: result, headers: params.headers, status: 200 }, validationUrl: params.url }, params));
+                        })];
+                case 1:
+                    _a.sent();
+                    expect(requestMock).not.toHaveBeenCalled();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should send api request on action request and name workflow', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var result, config, waitFor, params;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    result = { success: 'message' };
+                    requestMock.mockResolvedValue(result);
+                    config = createConfig({ permissions: ['/entity'] });
+                    waitFor = setUp({ config: config }).waitFor;
+                    params = {
+                        name: RequestAction.WORKFLOW,
+                        id: '1',
+                        url: '/entity',
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/json'
+                        },
+                        data: { field1: 'some data' }
+                    };
+                    act(function () {
+                        onmessageFromWorker({ action: CustomAction.REQUEST, params: params });
+                    });
+                    return [4 /*yield*/, waitFor(function () {
+                            return expect(postMessage).toHaveBeenCalledWith(__assign({ action: 'response', result: { data: result, headers: params.headers, status: 200 }, validationUrl: params.url }, params));
+                        })];
+                case 1:
+                    _a.sent();
+                    expect(requestMock).toHaveBeenCalledWith('https://tst-01-workflow.reltio.com/workflow-adapter/workflow/alenat/entity', {
+                        method: params.method,
+                        body: JSON.stringify(params.data),
+                        headers: {
+                            'Content-Type': 'application/json'
+                        }
+                    });
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should send api request to workflow with access token', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var result, mdmValues, config, waitFor, params;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    result = { success: 'message' };
+                    requestMock.mockImplementation(function (url, _options) {
+                        var isTokenRequest = url.includes('getTokenForWorker');
+                        return Promise.resolve(isTokenRequest ? { accessToken: 'some token' } : result);
+                    });
+                    mdmValues = __assign(__assign({}, defaultMdmValues), { servicesPath: '/nui/services' });
+                    config = createConfig({ permissions: ['/entity'] });
+                    waitFor = setUp({ mdmValues: mdmValues, config: config }).waitFor;
+                    params = {
+                        name: RequestAction.WORKFLOW,
+                        id: '1',
+                        url: '/entity',
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/json'
+                        },
+                        data: { field1: 'some data' }
+                    };
+                    act(function () {
+                        onmessageFromWorker({ action: CustomAction.REQUEST, params: params });
+                    });
+                    return [4 /*yield*/, waitFor(function () {
+                            return expect(postMessage).toHaveBeenCalledWith(__assign({ action: 'response', result: { data: result, headers: params.headers, status: 200 }, validationUrl: params.url }, params));
+                        })];
+                case 1:
+                    _a.sent();
+                    expect(requestMock).toHaveBeenCalledWith('https://tst-01-workflow.reltio.com/workflow-adapter/workflow/alenat/entity', {
+                        method: params.method,
+                        body: JSON.stringify(params.data),
+                        headers: {
+                            Authorization: 'Bearer some token',
+                            'Content-Type': 'application/json'
+                        }
+                    });
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should send api request on action request and name workflow and handle errors properly', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var config, waitFor, params;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    requestMock.mockImplementation(function (url, _options) {
+                        var isTokenRequest = url.includes('getTokenForWorker');
+                        return isTokenRequest
+                            ? Promise.resolve({ accessToken: 'some token' })
+                            : Promise.reject({ error: 'some error' });
+                    });
+                    config = createConfig({ permissions: ['https://tst-01-workflow.reltio.com'] });
+                    waitFor = setUp({ config: config }).waitFor;
+                    params = {
+                        name: RequestAction.WORKFLOW,
+                        id: '1',
+                        url: 'https://tst-01-workflow.reltio.com/workflow-adapter/workflow/alenat/entity',
+                        headers: {
+                            'Content-Type': 'application/json'
+                        }
+                    };
+                    act(function () {
+                        onmessageFromWorker({ action: CustomAction.REQUEST, params: params });
+                    });
+                    return [4 /*yield*/, waitFor(function () {
+                            return expect(postMessage).toHaveBeenCalledWith(__assign({ action: 'response', result: {
+                                    data: { error: 'some error' },
+                                    headers: params.headers,
+                                    status: 0
+                                }, validationUrl: params.url }, params));
+                        })];
+                case 1:
+                    _a.sent();
+                    expect(requestMock).toHaveBeenCalledWith(params.url, {
+                        method: 'GET',
+                        headers: {
+                            Authorization: 'Bearer some token',
+                            'Content-Type': 'application/json'
+                        }
+                    });
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should not start Process From Query on action request and name workflow/startProcessFromQuery if processDefinitionId is empty', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var waitFor, result, params;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    waitFor = setUp().waitFor;
+                    result = { errorMessage: 'processDefinitionId is empty' };
+                    params = {
+                        name: RequestAction.WORKFLOW_START_PROCESS_FROM_QUERY,
+                        id: '1',
+                        headers: {
+                            'Content-Type': 'application/json'
+                        }
+                    };
+                    act(function () {
+                        onmessageFromWorker({ action: CustomAction.REQUEST, params: params });
+                    });
+                    return [4 /*yield*/, waitFor(function () {
+                            return expect(postMessage).toHaveBeenCalledWith(__assign({ action: 'response', result: { data: result, headers: params.headers, status: 200 } }, params));
+                        })];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should not start Process From Query on action request and name workflow/startProcessFromQuery if searchString is empty', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var waitFor, result, params;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    waitFor = setUp().waitFor;
+                    result = { errorMessage: 'searchString is empty' };
+                    params = {
+                        name: RequestAction.WORKFLOW_START_PROCESS_FROM_QUERY,
+                        id: '1',
+                        processDefinitionId: '1',
+                        headers: {
+                            'Content-Type': 'application/json'
+                        }
+                    };
+                    act(function () {
+                        onmessageFromWorker({ action: CustomAction.REQUEST, params: params });
+                    });
+                    return [4 /*yield*/, waitFor(function () {
+                            return expect(postMessage).toHaveBeenCalledWith(__assign({ action: 'response', result: { data: result, headers: params.headers, status: 200 }, validationUrl: params.url }, params));
+                        })];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should not send api request on action request and name workflow/startProcessFromQuery if no permissions', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var config, waitFor, result, params;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    config = createConfig({ permissions: ['/tenant'] });
+                    waitFor = setUp({ config: config }).waitFor;
+                    result = { errorMessage: 'Not enough permissions' };
+                    params = {
+                        name: RequestAction.WORKFLOW_START_PROCESS_FROM_QUERY,
+                        id: '1',
+                        processDefinitionId: '1',
+                        searchString: 'search',
+                        headers: {
+                            'Content-Type': 'application/json'
+                        }
+                    };
+                    act(function () {
+                        onmessageFromWorker({ action: CustomAction.REQUEST, params: params });
+                    });
+                    return [4 /*yield*/, waitFor(function () {
+                            return expect(postMessage).toHaveBeenCalledWith(__assign({ action: 'response', result: { data: result, headers: params.headers, status: 200 }, validationUrl: params.url }, params));
+                        })];
+                case 1:
+                    _a.sent();
+                    expect(requestMock).not.toHaveBeenCalled();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should not send api request on action request and name workflow/startProcessFromQuery if no workflowPath', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mdmValues, config, waitFor, result, params;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mdmValues = __assign(__assign({}, defaultMdmValues), { workflowPath: undefined });
+                    config = createConfig({ permissions: ['/processInstances'] });
+                    waitFor = setUp({ mdmValues: mdmValues, config: config }).waitFor;
+                    result = { errorMessage: 'Workflow path is not defined' };
+                    params = {
+                        name: RequestAction.WORKFLOW_START_PROCESS_FROM_QUERY,
+                        id: '1',
+                        processDefinitionId: '1',
+                        searchString: 'search',
+                        headers: {
+                            'Content-Type': 'application/json'
+                        }
+                    };
+                    act(function () {
+                        onmessageFromWorker({ action: CustomAction.REQUEST, params: params });
+                    });
+                    return [4 /*yield*/, waitFor(function () {
+                            return expect(postMessage).toHaveBeenCalledWith(__assign({ action: 'response', result: { data: result, headers: params.headers, status: 200 }, validationUrl: params.url }, params));
+                        })];
+                case 1:
+                    _a.sent();
+                    expect(requestMock).not.toHaveBeenCalled();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should send api request on action request and name workflow/startProcessFromQuery', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var result, config, waitFor, params;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    result = { success: 'message' };
+                    requestMock.mockResolvedValue(result);
+                    config = createConfig({ permissions: ['/processInstances'] });
+                    waitFor = setUp({ config: config }).waitFor;
+                    params = {
+                        name: RequestAction.WORKFLOW_START_PROCESS_FROM_QUERY,
+                        id: '12',
+                        processDefinitionId: 'processDefinitionId',
+                        searchString: 'search',
+                        headers: {
+                            'Content-Type': 'application/json'
+                        }
+                    };
+                    act(function () {
+                        onmessageFromWorker({ action: CustomAction.REQUEST, params: params });
+                    });
+                    return [4 /*yield*/, waitFor(function () {
+                            return expect(postMessage).toHaveBeenCalledWith(__assign({ action: 'response', result: { data: result, headers: params.headers, status: 200 }, validationUrl: params.url }, params));
+                        })];
+                case 1:
+                    _a.sent();
+                    expect(requestMock).toHaveBeenCalledWith('https://tst-01-workflow.reltio.com/workflow-adapter/workflow/alenat/processInstances/_generateFromQuery?background=true', {
+                        method: 'POST',
+                        body: JSON.stringify({ processType: params.processDefinitionId, searchString: params.searchString }),
+                        headers: {
+                            'Content-Type': 'application/json'
+                        }
+                    });
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should pass configuration on getConfiguration request', function () {
+        setUp();
+        var params = {
+            name: RequestAction.GET_CONFIGURATION,
+            id: 23
+        };
+        act(function () {
+            onmessageFromWorker({ action: CustomAction.REQUEST, params: params });
+        });
+        expect(postMessage).toHaveBeenCalledWith(__assign({ action: 'response', result: metadata }, params));
+    });
+    it('should pass configuration on getUIConfiguration request', function () {
+        var config = createConfig();
+        setUp({ config: config });
+        var params = {
+            name: RequestAction.GET_UI_CONFIGURATION,
+            id: 23
+        };
+        act(function () {
+            onmessageFromWorker({ action: CustomAction.REQUEST, params: params });
+        });
+        expect(postMessage).toHaveBeenCalledWith(__assign({ action: 'response', result: config }, params));
+    });
+    it('should call setEntityUri from sandbox on setEntityUri request', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var getResponseCall, entity, params;
+        return __generator(this, function (_a) {
+            getResponseCall = function (postMessage) {
+                var _a;
+                return (_a = postMessage.mock.calls.find(function (_a) {
+                    var param = _a[0];
+                    return param.action === 'response';
+                })) === null || _a === void 0 ? void 0 : _a[0];
+            };
+            entity = { uri: 'entities/mnGg0XB' };
+            setUp();
+            params = {
+                name: RequestAction.SET_ENTITY_URI,
+                id: 23,
+                entityUri: 'entities/mnGg0XB'
+            };
+            act(function () {
+                onmessageFromWorker({ action: CustomAction.REQUEST, params: params });
+            });
+            expect(getResponseCall(postMessage)).toBeUndefined();
+            expect(sandbox.setEntityUri).toHaveBeenCalledTimes(1);
+            expect(sandbox.setEntityUri.mock.calls[0][0]).toBe(params.entityUri);
+            act(function () {
+                sandbox.setEntityUri.mock.calls[0][1](entity);
+            });
+            expect(getResponseCall(postMessage)).toEqual(__assign({ action: 'response', result: entity }, params));
+            return [2 /*return*/];
+        });
+    }); });
+    it('should call showPerspective and getCurrentPerspectiveId from sandbox on setPerspective request', function () {
+        setUp();
+        var params = {
+            name: RequestAction.SET_PERSPECTIVE,
+            perspective: 'test_perspective',
+            id: 23
+        };
+        act(function () {
+            onmessageFromWorker({ action: CustomAction.REQUEST, params: params });
+        });
+        expect(sandbox.showPerspective).toHaveBeenCalledWith(params.perspective);
+        expect(sandbox.getCurrentPerspectiveId).toHaveBeenCalledTimes(1);
+        expect(postMessage).toHaveBeenCalledWith(__assign({ action: 'response', result: '23' }, params));
+    });
+    it('should call getCurrentPerspectiveId from sandbox on getPerspective request', function () {
+        setUp();
+        var params = {
+            name: RequestAction.GET_PERSPECTIVE,
+            id: 23
+        };
+        act(function () {
+            onmessageFromWorker({ action: CustomAction.REQUEST, params: params });
+        });
+        expect(sandbox.getCurrentPerspectiveId).toHaveBeenCalledTimes(1);
+        expect(postMessage).toHaveBeenCalledWith(__assign({ action: 'response', result: '23' }, params));
+    });
+    it('should call workflowCheckPermission on workflow/checkPermission request', function () {
+        var workflowCheckPermission = jest.fn().mockReturnValue(true);
+        useWorkflowCheckPermission.mockReturnValue(workflowCheckPermission);
+        setUp();
+        var params = {
+            name: RequestAction.WORKFLOW_CHECK_PERMISSION,
+            id: 23,
+            permission: 'permission'
+        };
+        act(function () {
+            onmessageFromWorker({ action: CustomAction.REQUEST, params: params });
+        });
+        expect(workflowCheckPermission).toHaveBeenCalledTimes(1);
+        expect(workflowCheckPermission).toHaveBeenCalledWith(params.permission);
+        expect(postMessage).toHaveBeenCalledWith(__assign({ action: 'response', result: true }, params));
+    });
+    it('should send query on getSearchQuery request', function () {
+        setUp();
+        var params = {
+            name: RequestAction.GET_SEARCH_QUERY,
+            id: 23
+        };
+        act(function () {
+            onmessageFromWorker({ action: CustomAction.REQUEST, params: params });
+        });
+        expect(postMessage).toHaveBeenCalledWith(__assign({ action: 'response', result: 'some search' }, params));
+    });
+    it('should open search on openSearch request', function () {
+        setUp();
+        var params = {
+            name: RequestAction.OPEN_SEARCH,
+            searchState: {
+                data: {
+                    query: 'query'
+                }
+            },
+            id: 23
+        };
+        act(function () {
+            onmessageFromWorker({ action: CustomAction.REQUEST, params: params });
+        });
+        expect(mdmActions.openSearch).toHaveBeenCalledWith({
+            searchState: params.searchState,
+            viewId: 'com.reltio.plugins.entity.Anton03'
+        });
+    });
+    it('should open search on openSearch request with empty searchState', function () {
+        var params = {
+            name: RequestAction.OPEN_SEARCH,
+            searchState: undefined,
+            id: 23
+        };
+        act(function () {
+            onmessageFromWorker({ action: CustomAction.REQUEST, params: params });
+        });
+        expect(mdmActions.openSearch).toHaveBeenCalledWith({
+            searchState: {},
+            viewId: 'com.reltio.plugins.entity.Anton03'
+        });
+    });
+    it('should return entityUri on getEntityUri request', function () {
+        setUp();
+        var params = {
+            name: RequestAction.GET_ENTITY_URI,
+            id: 23
+        };
+        act(function () {
+            onmessageFromWorker({ action: CustomAction.REQUEST, params: params });
+        });
+        expect(postMessage).toHaveBeenCalledWith(__assign({ action: 'response', result: 'entities/mnGg0XB' }, params));
+    });
+    it('should return entity on getEntity request', function () {
+        setUp();
+        var params = {
+            name: RequestAction.GET_ENTITY,
+            id: 23
+        };
+        act(function () {
+            onmessageFromWorker({ action: CustomAction.REQUEST, params: params });
+        });
+        expect(postMessage).toHaveBeenCalledWith(__assign({ action: 'response', result: entity }, params));
+    });
+    it('should return correct apiPath on getApiPath request', function () {
+        var mdmValues = __assign(__assign({}, defaultMdmValues), { servicesPath: 'https://tst-01.reltio.com/nui/services' });
+        setUp({ mdmValues: mdmValues });
+        var params = {
+            name: RequestAction.GET_API_PATH,
+            id: 23
+        };
+        act(function () {
+            onmessageFromWorker({ action: CustomAction.REQUEST, params: params });
+        });
+        expect(postMessage).toHaveBeenCalledWith(__assign({ action: 'response', result: 'https://tst-01.reltio.com/reltio' }, params));
+    });
+    it('should return workflowPath on getWorkflowPath request', function () {
+        setUp();
+        var params = {
+            name: RequestAction.WORKFLOW_GET_WORKFLOW_PATH,
+            id: 23
+        };
+        act(function () {
+            onmessageFromWorker({ action: CustomAction.REQUEST, params: params });
+        });
+        expect(postMessage).toHaveBeenCalledWith(__assign({ action: 'response', result: 'https://tst-01-workflow.reltio.com/workflow-adapter' }, params));
+    });
+    it('should return tenant on getTenant request', function () {
+        setUp();
+        var params = {
+            name: RequestAction.GET_TENANT,
+            id: 23
+        };
+        act(function () {
+            onmessageFromWorker({ action: CustomAction.REQUEST, params: params });
+        });
+        expect(postMessage).toHaveBeenCalledWith(__assign({ action: 'response', result: 'alenat' }, params));
+    });
+    it('should return user on getUser request', function () {
+        setUp();
+        var params = {
+            name: RequestAction.GET_USER,
+            id: 23
+        };
+        act(function () {
+            onmessageFromWorker({ action: CustomAction.REQUEST, params: params });
+        });
+        expect(postMessage).toHaveBeenCalledWith(__assign({ action: 'response', result: { username: 'alexey.starodubtsev' } }, params));
+    });
+    it('should call alert on alert request', function () {
+        setUp();
+        var alert = jest.fn();
+        window.alert = alert;
+        var params = {
+            name: RequestAction.ALERT,
+            text: 'hello',
+            id: 23
+        };
+        act(function () {
+            onmessageFromWorker({ action: CustomAction.REQUEST, params: params });
+        });
+        expect(alert).toHaveBeenCalledWith(params.text);
+        expect(postMessage).toHaveBeenCalledWith(__assign({ action: 'response' }, params));
+    });
+    it('should call confirm on confirm request', function () {
+        setUp();
+        var confirm = jest.fn();
+        window.confirm = confirm;
+        var params = {
+            name: RequestAction.CONFIRM,
+            text: 'hello',
+            id: 23
+        };
+        act(function () {
+            onmessageFromWorker({ action: CustomAction.REQUEST, params: params });
+        });
+        expect(confirm).toHaveBeenCalledWith(params.text);
+        expect(postMessage).toHaveBeenCalledWith(__assign({ action: 'response' }, params));
+    });
+    it('should call prompt on prompt request', function () {
+        setUp();
+        var prompt = jest.fn();
+        window.prompt = prompt;
+        var params = {
+            name: RequestAction.PROMPT,
+            text: 'hello',
+            defaultText: 'defaultText',
+            id: 23
+        };
+        act(function () {
+            onmessageFromWorker({ action: CustomAction.REQUEST, params: params });
+        });
+        expect(prompt).toHaveBeenCalledWith(params.text, params.defaultText);
+        expect(postMessage).toHaveBeenCalledWith(__assign({ action: 'response' }, params));
+    });
+    it('should open new window on openWindow request', function () {
+        setUp();
+        var openWindow = jest.fn();
+        window.open = openWindow;
+        var params = {
+            name: RequestAction.OPEN_WINDOW,
+            url: 'https://reltio.com',
+            id: 23
+        };
+        act(function () {
+            onmessageFromWorker({ action: CustomAction.REQUEST, params: params });
+        });
+        expect(openWindow).toHaveBeenCalledWith(params.url, '_blank');
+    });
+    it('should not initialize web worker with unsupported custom script', function () {
+        var config = createConfig({ platform: CustomScriptPlatform.CLASSIC });
+        var unmount = setUp({ config: config }).unmount;
+        expect(initializeWebWorker).toHaveBeenCalledTimes(0);
+        unmount();
+    });
+    it('should call location.reload on UI.reloadPage()', function () {
+        setUp();
+        Object.defineProperty(window, 'location', {
+            configurable: true,
+            value: { reload: jest.fn() }
+        });
+        var params = {
+            name: RequestAction.RELOAD_PAGE
+        };
+        act(function () {
+            onmessageFromWorker({ action: CustomAction.REQUEST, params: params });
+        });
+        expect(window.location.reload).toHaveBeenCalled();
+    });
+    it('should use interceptors', function () {
+        var mdmValues = __assign(__assign({}, defaultMdmValues), { servicesPath: 'https://tst-01.reltio.com/nui/services' });
+        var config = createConfig({ processApiRequest: [], processApiResponse: [] });
+        var unmount = setUp({ mdmValues: mdmValues, config: config }).unmount;
+        expect(interceptors.addInternalRequestInterceptor).toBeCalledTimes(1);
+        expect(interceptors.addInternalResponseInterceptor).toBeCalledTimes(1);
+        expect(interceptors.removeInternalRequestInterceptor).toBeCalledTimes(0);
+        expect(interceptors.removeInternalResponseInterceptor).toBeCalledTimes(0);
+        unmount();
+        expect(interceptors.removeInternalRequestInterceptor).toBeCalledTimes(1);
+        expect(interceptors.removeInternalResponseInterceptor).toBeCalledTimes(1);
+        expect(interceptors.startInterceptorInit).toBeCalledTimes(1);
+        expect(interceptors.finishInterceptorInit).toBeCalledTimes(1);
+    });
+    it('should not start Process Instance on action request and name workflow/startProcessInstance if processDefinitionId is empty', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var waitFor, result, params;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    waitFor = setUp().waitFor;
+                    result = { errorMessage: 'processDefinitionId is empty' };
+                    params = {
+                        name: RequestAction.WORKFLOW_START_PROCESS_INSTANCE,
+                        id: '1',
+                        headers: {
+                            'Content-Type': 'application/json'
+                        }
+                    };
+                    act(function () {
+                        onmessageFromWorker({ action: CustomAction.REQUEST, params: params });
+                    });
+                    return [4 /*yield*/, waitFor(function () {
+                            return expect(postMessage).toHaveBeenCalledWith(__assign({ action: 'response', result: { data: result, headers: params.headers, status: 200 } }, params));
+                        })];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should not start Process Instance on action request and name workflow/startProcessInstance if changeRequestURI is empty', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var waitFor, result, params;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    waitFor = setUp().waitFor;
+                    result = { errorMessage: 'changeRequestURI is empty' };
+                    params = {
+                        name: RequestAction.WORKFLOW_START_PROCESS_INSTANCE,
+                        id: '1',
+                        processDefinitionId: 'dataChangeRequestReview',
+                        headers: {
+                            'Content-Type': 'application/json'
+                        }
+                    };
+                    act(function () {
+                        onmessageFromWorker({ action: CustomAction.REQUEST, params: params });
+                    });
+                    return [4 /*yield*/, waitFor(function () {
+                            return expect(postMessage).toHaveBeenCalledWith(__assign({ action: 'response', result: { data: result, headers: params.headers, status: 200 }, validationUrl: params.url }, params));
+                        })];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should not send api request on action request and name workflow/startProcessInstance if no permissions', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var config, waitFor, result, params;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    config = createConfig({ permissions: ['/tenant'] });
+                    waitFor = setUp({ config: config }).waitFor;
+                    result = { errorMessage: 'Not enough permissions' };
+                    params = {
+                        name: RequestAction.WORKFLOW_START_PROCESS_INSTANCE,
+                        id: '1',
+                        processDefinitionId: 'dataChangeRequestReview',
+                        changeRequestURI: 'changeRequests/123abc',
+                        comment: "Category: HCO Profile Change, Request: let's change it",
+                        headers: {
+                            'Content-Type': 'application/json'
+                        }
+                    };
+                    act(function () {
+                        onmessageFromWorker({ action: CustomAction.REQUEST, params: params });
+                    });
+                    return [4 /*yield*/, waitFor(function () {
+                            return expect(postMessage).toHaveBeenCalledWith(__assign({ action: 'response', result: { data: result, headers: params.headers, status: 200 }, validationUrl: params.url }, params));
+                        })];
+                case 1:
+                    _a.sent();
+                    expect(requestMock).not.toHaveBeenCalled();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should not send api request on action request and name workflow/startProcessInstance if no workflowPath', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var mdmValues, config, waitFor, result, params;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    mdmValues = __assign(__assign({}, defaultMdmValues), { workflowPath: undefined });
+                    config = createConfig({ permissions: ['/processInstances'] });
+                    waitFor = setUp({ mdmValues: mdmValues, config: config }).waitFor;
+                    result = { errorMessage: 'Workflow path is not defined' };
+                    params = {
+                        name: RequestAction.WORKFLOW_START_PROCESS_INSTANCE,
+                        id: '1',
+                        processDefinitionId: 'dataChangeRequestReview',
+                        changeRequestURI: 'changeRequests/123abc',
+                        comment: "Category: HCO Profile Change, Request: let's change it",
+                        headers: {
+                            'Content-Type': 'application/json'
+                        }
+                    };
+                    act(function () {
+                        onmessageFromWorker({ action: CustomAction.REQUEST, params: params });
+                    });
+                    return [4 /*yield*/, waitFor(function () {
+                            return expect(postMessage).toHaveBeenCalledWith(__assign({ action: 'response', result: { data: result, headers: params.headers, status: 200 }, validationUrl: params.url }, params));
+                        })];
+                case 1:
+                    _a.sent();
+                    expect(requestMock).not.toHaveBeenCalled();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    it('should send api request on action request and name workflow/startProcessInstance', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var result, config, waitFor, params;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    result = { success: 'message' };
+                    requestMock.mockResolvedValue(result);
+                    config = createConfig({ permissions: ['/processInstances'] });
+                    waitFor = setUp({ config: config }).waitFor;
+                    params = {
+                        name: RequestAction.WORKFLOW_START_PROCESS_INSTANCE,
+                        id: '12',
+                        processDefinitionId: 'dataChangeRequestReview',
+                        changeRequestURI: 'changeRequests/123abc',
+                        comment: "Category: HCO Profile Change, Request: let's change it",
+                        headers: {
+                            'Content-Type': 'application/json'
+                        }
+                    };
+                    act(function () {
+                        onmessageFromWorker({ action: CustomAction.REQUEST, params: params });
+                    });
+                    return [4 /*yield*/, waitFor(function () {
+                            return expect(postMessage).toHaveBeenCalledWith(__assign({ action: 'response', result: { data: result, headers: params.headers, status: 200 }, validationUrl: params.url }, params));
+                        })];
+                case 1:
+                    _a.sent();
+                    expect(requestMock).toHaveBeenCalledWith('https://tst-01-workflow.reltio.com/workflow-adapter/workflow/alenat/processInstances', {
+                        method: 'POST',
+                        body: JSON.stringify({
+                            processType: params.processDefinitionId,
+                            objectURIs: ['entities/mnGg0XB', params.changeRequestURI],
+                            comment: params.comment
+                        }),
+                        headers: {
+                            'Content-Type': 'application/json'
+                        }
+                    });
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    describe('event messages', function () {
+        var getEvent = function (type, data) { return ({ action: 'event', data: data, type: type }); };
+        var getLastEventCall = function (postMessage, event) {
+            var _a;
+            return (_a = __spreadArray([], postMessage.mock.calls, true).reverse().find(function (_a) {
+                var call = _a[0];
+                return call.type === event;
+            })) === null || _a === void 0 ? void 0 : _a[0];
+        };
+        it('should send updateEntity/editMode/changeSearchQuery/changeVisibility events on component load', function () {
+            setUp();
+            expect(postMessage.mock.calls).toEqual([
+                [getEvent('updateEntity', entity)],
+                [getEvent('editMode', false)],
+                [getEvent('changeSearchQuery', searchProviderData.data.query)],
+                [getEvent('changeVisibility', true)]
+            ]);
+        });
+        it('should send execute event on onClick calls', function () {
+            var result = setUp().result;
+            expect(getLastEventCall(postMessage, 'execute')).toBeUndefined();
+            var onClick = result.current.onClick;
+            onClick();
+            expect(postMessage).toHaveBeenCalledWith(getEvent('execute', null));
+        });
+        it('should send updateEntity event on entity changes', function () {
+            var updateMdmValues = setUp().updateMdmValues;
+            expect(postMessage).toHaveBeenCalledWith(getEvent('updateEntity', entity));
+            var newEntity = { uri: 'entities/mnG123', type: 'configuration/entityTypes/HCP' };
+            act(function () {
+                updateMdmValues(function (prev) { return (__assign(__assign({}, prev), { entity: newEntity })); });
+            });
+            expect(getLastEventCall(postMessage, 'updateEntity')).toEqual(getEvent('updateEntity', newEntity));
+        });
+        it('should send editMode event on mode changes', function () {
+            var updateMdmValues = setUp().updateMdmValues;
+            expect(postMessage).toHaveBeenCalledWith(getEvent('editMode', false));
+            act(function () {
+                updateMdmValues(function (prev) { return (__assign(__assign({}, prev), { mode: Mode.Editing })); });
+            });
+            expect(getLastEventCall(postMessage, 'editMode')).toEqual(getEvent('editMode', true));
+            act(function () {
+                updateMdmValues(function (prev) { return (__assign(__assign({}, prev), { mode: Mode.Viewing })); });
+            });
+            expect(getLastEventCall(postMessage, 'editMode')).toEqual(getEvent('editMode', false));
+            act(function () {
+                updateMdmValues(function (prev) { return (__assign(__assign({}, prev), { mode: Mode.Suggesting })); });
+            });
+            expect(getLastEventCall(postMessage, 'editMode')).toEqual(getEvent('editMode', true));
+        });
+        it('should send changeSearchQuery event on searchQuery changes', function () {
+            var updateMdmValues = setUp().updateMdmValues;
+            expect(postMessage).toHaveBeenCalledWith(getEvent('changeSearchQuery', searchProviderData.data.query));
+            act(function () {
+                var searchProviderData = { data: { query: 'other' }, type: 'search' };
+                updateMdmValues(function (prev) { return (__assign(__assign({}, prev), { searchProviderData: searchProviderData })); });
+            });
+            expect(postMessage).toHaveBeenLastCalledWith(getEvent('changeSearchQuery', 'other'));
+        });
+        it('should send changeVisibility event on visibility changes', function () {
+            setUp();
+            expect(getLastEventCall(postMessage, 'changeVisibility')).toEqual(getEvent('changeVisibility', true));
+            act(function () {
+                onmessageFromWorker({ action: CustomAction.SET_VISIBILITY, params: 'hidden' });
+            });
+            expect(getLastEventCall(postMessage, 'changeVisibility')).toEqual(getEvent('changeVisibility', false));
+            act(function () {
+                onmessageFromWorker({ action: CustomAction.SET_VISIBILITY, params: 'visible' });
+            });
+            expect(getLastEventCall(postMessage, 'changeVisibility')).toEqual(getEvent('changeVisibility', true));
+        });
+    });
+});