@sap/open.fe 1.98.0 → 1.99.0

package/packages/sap.fe.core/test/sap/fe/core/jest/controllerextensions/InternalEditFlow.spec.ts

@@ -0,0 +1,440 @@
+import { MockContext, MockMetaModel, MockModel } from "sap/fe/test/UI5MockHelper";
+
+import { InternalEditFlow } from "sap/fe/core/controllerextensions";
+import TransactionHelper from "sap/fe/core/TransactionHelper";
+import CommonUtils from "sap/fe/core/CommonUtils";
+import BusyLocker from "sap/fe/core/BusyLocker";
+
+describe("InternalEditFlow ControllerExtension", function() {
+	const oTestReferences = {
+		"references": [
+			{
+				"type": "JIRA",
+				"ID": "FIORITECHP1-22294"
+			}
+		]
+	};
+	afterAll(() => {
+		jest.resetAllMocks();
+	});
+	describe("createMultipleDocuments - onBeforeCreate", () => {
+		let oTransactionHelper: any, oInternalEditFlow: any;
+		let oGetTransactionHelperMock,
+			oGetGlobalUIModellMock,
+			oGetViewMock,
+			oBusyLockMock,
+			oSyncTaskMock,
+			oHandleCreateEventsMock,
+			oGetMessageHandlerMock,
+			oHasTransientContextMock,
+			oBusyUnlockMock,
+			oOnBeforeCreateMock,
+			oListBinding: any,
+			oCreateDocumentMock: any;
+		let oMockModel = new MockModel();
+		let oMockMetaModel = new MockMetaModel();
+		let oMockContext = new MockContext({ $path: "SalesOrderItem" });
+		oMockModel.setMetaModel(oMockMetaModel);
+		beforeEach(() => {
+			oInternalEditFlow = new InternalEditFlow();
+			oTransactionHelper = new TransactionHelper(null, null);
+			oGetTransactionHelperMock = jest.spyOn(oInternalEditFlow as any, "getTransactionHelper");
+			oGetTransactionHelperMock.mockImplementation(() => {
+				return oTransactionHelper;
+			});
+			oGetGlobalUIModellMock = jest.spyOn(oInternalEditFlow as any, "getGlobalUIModel");
+			oGetGlobalUIModellMock.mockImplementation(() => undefined);
+			oGetViewMock = jest.spyOn(oInternalEditFlow as any, "getView");
+			oGetViewMock.mockImplementation(() => {
+				return {
+					getController: function() {
+						return {
+							oResourceBundle: null
+						};
+					},
+					getBindingContext: function() {
+						return null;
+					}
+				};
+			});
+			oBusyLockMock = jest.spyOn(BusyLocker, "lock");
+			oBusyLockMock.mockReturnValue(true);
+			oBusyUnlockMock = jest.spyOn(BusyLocker, "unlock");
+			oBusyUnlockMock.mockReturnValue(true);
+			oSyncTaskMock = jest.spyOn(oInternalEditFlow as any, "syncTask");
+			oSyncTaskMock.mockResolvedValue(null);
+			oHandleCreateEventsMock = jest.spyOn(oInternalEditFlow as any, "handleCreateEvents");
+			oHandleCreateEventsMock.mockReturnValue(true);
+			oGetMessageHandlerMock = jest.spyOn(oInternalEditFlow as any, "getMessageHandler");
+			oGetMessageHandlerMock.mockReturnValue(true);
+			oHasTransientContextMock = jest.spyOn(CommonUtils, "hasTransientContext");
+			oHasTransientContextMock.mockReturnValue(true);
+			oHasTransientContextMock.mockReturnValue(true);
+			oListBinding = {
+				getModel: function() {
+					return oMockModel;
+				},
+				getContext: function() {
+					return oMockContext;
+				},
+				getPath: function() {
+					return "/SalesOrderItem";
+				}
+			};
+			oCreateDocumentMock = jest.spyOn(oTransactionHelper, "createDocument");
+			oCreateDocumentMock.mockResolvedValue({
+				created: function() {
+					return null;
+				}
+			});
+		});
+		afterEach(() => {
+			jest.restoreAllMocks();
+		});
+
+		it("onBeforeCreate is resolved", async () => {
+			const aData = [
+				{
+					"SalesOrder": 6437
+				}
+			];
+
+			oOnBeforeCreateMock = jest.fn(() => {
+				return Promise.resolve();
+			});
+			await (oInternalEditFlow as any).createMultipleDocuments(oListBinding, aData, true, true, oOnBeforeCreateMock);
+			expect(oOnBeforeCreateMock).toHaveBeenCalledWith({ contextPath: oListBinding.getPath() });
+			expect(oCreateDocumentMock).toHaveBeenCalledTimes(1);
+		});
+		it("onBeforeCreate is rejected", async () => {
+			const aData = [
+				{
+					"SalesOrder": 6437
+				}
+			];
+
+			oOnBeforeCreateMock = jest.fn(() => {
+				return Promise.reject();
+			});
+			try {
+				await (oInternalEditFlow as any).createMultipleDocuments(oListBinding, aData, true, true, oOnBeforeCreateMock);
+			} catch {
+				expect(oOnBeforeCreateMock).toHaveBeenCalledWith({ contextPath: oListBinding.getPath() });
+				expect(oCreateDocumentMock).toHaveBeenCalledTimes(0);
+			}
+		});
+	});
+
+	describe("testing - _hasNewActionForSticky", () => {
+		let oInternalEditFlow: any, spyGetModel: any, spyGetMetaModel: any, spyContextGetPath: any, sCustomAction: string;
+		const mockContext = {
+			getPath: jest.fn(() => "")
+		};
+		const mockView = {
+			getModel: jest.fn()
+		};
+		const mockModel = {
+			getMetaModel: jest.fn()
+		};
+		const mockMetaModel = {
+			getObject: jest.fn()
+		};
+		beforeAll(() => {
+			oInternalEditFlow = new InternalEditFlow();
+			mockModel.getMetaModel.mockReturnValue(mockMetaModel);
+			mockView.getModel.mockReturnValue(mockModel);
+			spyGetModel = jest.spyOn(mockView, "getModel");
+			spyGetMetaModel = jest.spyOn(mockModel, "getMetaModel");
+			spyContextGetPath = jest.spyOn(mockContext, "getPath");
+		});
+		beforeEach(() => {});
+		afterEach(() => {
+			jest.clearAllMocks();
+		});
+		it("_hasNewActionForSticky: invalid input parameters", oTestReferences, async () => {
+			const bResponse = await oInternalEditFlow._hasNewActionForSticky(undefined, undefined);
+			expect(bResponse).toEqual(undefined);
+			expect(spyGetModel).toHaveBeenCalledTimes(0);
+			expect(spyGetMetaModel).toHaveBeenCalledTimes(0);
+			expect(spyContextGetPath).toHaveBeenCalledTimes(0);
+		});
+		it("_hasNewActionForSticky: empty input parameters", oTestReferences, async () => {
+			const bResponse = await oInternalEditFlow._hasNewActionForSticky(mockContext, mockView);
+			expect(bResponse).toEqual(false);
+		});
+		it("_hasNewActionForSticky: missing context", oTestReferences, async () => {
+			mockMetaModel.getObject.mockReturnValue({
+				NewAction: "com.sap.gateway.srvd.ui_salesquotationmanage.v0001.CreateWithSalesQuotationType"
+			});
+			const bResponse = await oInternalEditFlow._hasNewActionForSticky(mockContext, mockView);
+			expect(bResponse).toEqual(false);
+		});
+		it("_hasNewActionForSticky: missing NewAction/AdditionalNewAction", oTestReferences, async () => {
+			mockContext.getPath.mockReturnValue("/SalesQuotationManage('')");
+			sCustomAction = "com.sap.gateway.srvd.ui_salesquotationmanage.v0001.CreateWithSalesQuotationType";
+			mockMetaModel.getObject.mockReturnValue({
+				DiscardAction: "DiscardChanges",
+				EditAction: "com.sap.gateway.srvd.ui_salesquotationmanage.v0001.PrepareForEdit",
+				SaveAction: "com.sap.gateway.srvd.ui_salesquotationmanage.v0001.SaveChanges"
+			});
+			const bResponse = await oInternalEditFlow._hasNewActionForSticky(mockContext, mockView, sCustomAction);
+			expect(bResponse).toEqual(false);
+		});
+		it("_hasNewActionForSticky: NewAction available", oTestReferences, async () => {
+			mockContext.getPath.mockReturnValue("/SalesQuotationManage('')");
+			sCustomAction = "com.sap.gateway.srvd.ui_salesquotationmanage.v0001.CreateWithSalesQuotationType";
+			mockMetaModel.getObject.mockReturnValue({
+				DiscardAction: "DiscardChanges",
+				EditAction: "com.sap.gateway.srvd.ui_salesquotationmanage.v0001.PrepareForEdit",
+				SaveAction: "com.sap.gateway.srvd.ui_salesquotationmanage.v0001.SaveChanges",
+				NewAction: "com.sap.gateway.srvd.ui_salesquotationmanage.v0001.CreateWithSalesQuotationType"
+			});
+			const bResponse = await oInternalEditFlow._hasNewActionForSticky(mockContext, mockView, sCustomAction);
+			expect(bResponse).toEqual(true);
+		});
+		it("_hasNewActionForSticky: AdditionalNewAction available", oTestReferences, async () => {
+			mockContext.getPath.mockReturnValue("/SalesQuotationManage('')");
+			sCustomAction = "com.sap.gateway.srvd.ui_salesquotationmanage.v0001.CreateWithSalesQuotationType";
+			mockMetaModel.getObject.mockReturnValue({
+				AdditionalNewActions: [
+					"com.sap.gateway.srvd.ui_salesquotationmanage.v0001.CreateWithRefFromSlsInquiry",
+					"com.sap.gateway.srvd.ui_salesquotationmanage.v0001.CreateWithSalesQuotationType"
+				],
+				DiscardAction: "DiscardChanges",
+				EditAction: "com.sap.gateway.srvd.ui_salesquotationmanage.v0001.PrepareForEdit",
+				SaveAction: "com.sap.gateway.srvd.ui_salesquotationmanage.v0001.SaveChanges"
+			});
+			const bResponse = await oInternalEditFlow._hasNewActionForSticky(mockContext, mockView, sCustomAction);
+			expect(bResponse).toEqual(true);
+			expect(spyGetModel).toHaveBeenCalledTimes(1);
+			expect(spyGetMetaModel).toHaveBeenCalledTimes(1);
+			expect(spyContextGetPath).toHaveBeenCalledTimes(2);
+		});
+		it("_hasNewActionForSticky: AdditionalNewAction available but not the relevant one", oTestReferences, async () => {
+			mockContext.getPath.mockReturnValue("/SalesQuotationManage('')");
+			sCustomAction = "com.sap.gateway.srvd.ui_salesquotationmanage.v0001.CreateWithSalesQuotationType";
+			mockMetaModel.getObject.mockReturnValue({
+				AdditionalNewActions: [
+					"com.sap.gateway.srvd.ui_salesquotationmanage.v0001.CreateWithRefFromSlsInquiry",
+					"com.sap.gateway.srvd.ui_salesquotationmanage.v0001.CreateWithSalesOrderType"
+				],
+				DiscardAction: "DiscardChanges",
+				EditAction: "com.sap.gateway.srvd.ui_salesquotationmanage.v0001.PrepareForEdit",
+				SaveAction: "com.sap.gateway.srvd.ui_salesquotationmanage.v0001.SaveChanges"
+			});
+			const bResponse = await oInternalEditFlow._hasNewActionForSticky(mockContext, mockView, sCustomAction);
+			expect(bResponse).toEqual(false);
+			expect(spyGetModel).toHaveBeenCalledTimes(1);
+			expect(spyGetMetaModel).toHaveBeenCalledTimes(1);
+			expect(spyContextGetPath).toHaveBeenCalledTimes(2);
+		});
+	});
+
+	describe("testing handleStickyOn()", () => {
+		let oInternalEditFlow: any,
+			spyGetView: any,
+			spyGetAppComponent: any,
+			spyGetRouterProxy: any,
+			spyHasNavigationGuard: any,
+			spySetNavigationGuard: any,
+			spyGetHash: any,
+			spyGetInternalModel: any,
+			spySetBackNavigation: any,
+			spyRegisterDirtyStateProvider: any,
+			spyGetModel: any,
+			spyAttachSessionTimeout: any,
+			spyAttachRouteMatched: any;
+		const mockGetShellServices = {
+			setBackNavigation: jest.fn().mockReturnValue(undefined),
+			registerDirtyStateProvider: jest.fn()
+		};
+		const mockGetRouterProxy = {
+			hasNavigationGuard: jest.fn(),
+			setNavigationGuard: jest.fn(),
+			getHash: jest.fn().mockReturnValue("")
+		};
+		const mockGetRoutingService = {
+			attachRouteMatched: jest.fn().mockReturnValue(undefined)
+		};
+		const mockGetAppComponent = {
+			getRouterProxy: jest.fn().mockReturnValue(mockGetRouterProxy),
+			getShellServices: jest.fn().mockReturnValue(mockGetShellServices),
+			getRoutingService: jest.fn().mockReturnValue(mockGetRoutingService)
+		};
+		const mockContext = {};
+		const mockGetModel = {
+			attachSessionTimeout: jest.fn().mockReturnValue(undefined)
+		};
+		const mockGetView = {
+			getModel: jest.fn().mockReturnValue(mockGetModel)
+		};
+		beforeAll(() => {
+			oInternalEditFlow = new InternalEditFlow();
+			spyGetView = jest.spyOn(oInternalEditFlow, "getView");
+			spyGetView.mockImplementation(() => mockGetView);
+			spyGetModel = jest.spyOn(mockGetView, "getModel");
+			spyAttachSessionTimeout = jest.spyOn(mockGetModel, "attachSessionTimeout");
+			spyGetAppComponent = jest.spyOn(CommonUtils, "getAppComponent");
+			spyGetRouterProxy = jest.spyOn(mockGetAppComponent, "getRouterProxy");
+			spyHasNavigationGuard = jest.spyOn(mockGetRouterProxy, "hasNavigationGuard");
+			spySetNavigationGuard = jest.spyOn(mockGetRouterProxy, "setNavigationGuard");
+			spyGetHash = jest.spyOn(mockGetRouterProxy, "getHash");
+			spyGetInternalModel = jest.spyOn(oInternalEditFlow, "getInternalModel");
+			spyGetInternalModel.mockImplementation(() => {
+				return {};
+			});
+			spySetBackNavigation = jest.spyOn(mockGetShellServices, "setBackNavigation");
+			spyRegisterDirtyStateProvider = jest.spyOn(mockGetShellServices, "registerDirtyStateProvider");
+			spyAttachRouteMatched = jest.spyOn(mockGetRoutingService, "attachRouteMatched");
+		});
+		afterEach(() => {
+			jest.clearAllMocks();
+		});
+		it("handleStickyOn: input paramater oContext is undefined", oTestReferences, async () => {
+			spyGetAppComponent.mockImplementation(() => {
+				return undefined;
+			});
+			const bResponse = await oInternalEditFlow.handleStickyOn(undefined);
+			expect(bResponse).toEqual(undefined);
+			expect(spyGetAppComponent).toHaveBeenCalledTimes(1);
+		});
+		it("handleStickyOn: input paramater oContext is empty", oTestReferences, async () => {
+			spyGetAppComponent.mockImplementation(() => {
+				return {};
+			});
+			const bResponse = await oInternalEditFlow.handleStickyOn(mockContext);
+			expect(bResponse).toEqual(undefined);
+			expect(spyGetAppComponent).toHaveBeenCalledTimes(1);
+		});
+		it("handleStickyOn: check valid input", oTestReferences, async () => {
+			spyGetAppComponent.mockImplementation(() => {
+				return mockGetAppComponent;
+			});
+			spyHasNavigationGuard.mockImplementation(() => {
+				return false;
+			});
+			const bResponse = await oInternalEditFlow.handleStickyOn(mockContext);
+			expect(bResponse).toEqual(true);
+			expect(spyGetAppComponent).toHaveBeenCalledTimes(1);
+			expect(spyGetRouterProxy).toHaveBeenCalledTimes(2);
+			expect(spyHasNavigationGuard).toHaveBeenCalledTimes(1);
+			expect(spyGetHash).toHaveBeenCalledTimes(1);
+			expect(spySetNavigationGuard).toHaveBeenCalledTimes(0);
+			expect(spySetBackNavigation).toHaveBeenCalledTimes(1);
+			expect(spyRegisterDirtyStateProvider).toHaveBeenCalledTimes(1);
+			expect(spyAttachSessionTimeout).toHaveBeenCalledTimes(1);
+			expect(spyAttachRouteMatched).toHaveBeenCalledTimes(1);
+		});
+		it("handleStickyOn: navigation guard already set", oTestReferences, async () => {
+			spyGetAppComponent.mockImplementation(() => {
+				return mockGetAppComponent;
+			});
+			spyHasNavigationGuard.mockImplementation(() => {
+				return true;
+			});
+			const bResponse = await oInternalEditFlow.handleStickyOn(mockContext);
+			expect(bResponse).toEqual(true);
+			expect(spyGetAppComponent).toHaveBeenCalledTimes(1);
+			expect(spyGetRouterProxy).toHaveBeenCalledTimes(1);
+			expect(spyHasNavigationGuard).toHaveBeenCalledTimes(1);
+			expect(spyGetHash).toHaveBeenCalledTimes(0);
+			expect(spySetNavigationGuard).toHaveBeenCalledTimes(0);
+			expect(spySetBackNavigation).toHaveBeenCalledTimes(0);
+			expect(spyRegisterDirtyStateProvider).toHaveBeenCalledTimes(0);
+			expect(spyAttachSessionTimeout).toHaveBeenCalledTimes(0);
+			expect(spyAttachRouteMatched).toHaveBeenCalledTimes(0);
+		});
+	});
+
+	describe("testing handleStickyOff()", () => {
+		let oInternalEditFlow: any,
+			oTransactionHelper: any,
+			spyGetView: any,
+			spySetEditMode: any,
+			spyGetAppComponent: any,
+			spyGetTransactionHelper: any,
+			spyDiscardNavigationGuard: any,
+			spyDeregisterDirtyStateProvider: any;
+		const mockGetAppComponent = {
+			getRouterProxy: jest.fn(),
+			getShellServices: jest.fn(),
+			getRoutingService: jest.fn()
+		};
+		const mockDiscardNavigationGuard = {
+			discardNavigationGuard: jest.fn().mockReturnValue(undefined)
+		};
+		const mockGetShellServices = {
+			deregisterDirtyStateProvider: jest.fn().mockReturnValue(undefined),
+			setBackNavigation: jest.fn().mockReturnValue(undefined)
+		};
+		const mockGetRoutingService = {
+			detachRouteMatched: jest.fn().mockReturnValue(undefined)
+		};
+		const mockGetModel = {
+			getModel: jest.fn()
+		};
+		const mockDetachSessionTimeout = {
+			detachSessionTimeout: jest.fn().mockReturnValue(undefined)
+		};
+		beforeAll(() => {
+			oInternalEditFlow = new InternalEditFlow();
+			oTransactionHelper = new TransactionHelper(null, null);
+			mockGetAppComponent.getRouterProxy.mockReturnValue(mockDiscardNavigationGuard);
+			mockGetAppComponent.getShellServices.mockReturnValue(mockGetShellServices);
+			mockGetAppComponent.getRoutingService.mockReturnValue(mockGetRoutingService);
+			mockGetModel.getModel.mockReturnValue(mockDetachSessionTimeout);
+			spyGetAppComponent = jest.spyOn(CommonUtils, "getAppComponent");
+			spyDiscardNavigationGuard = jest.spyOn(mockDiscardNavigationGuard, "discardNavigationGuard");
+			spyDeregisterDirtyStateProvider = jest.spyOn(mockGetShellServices, "deregisterDirtyStateProvider");
+			spyGetTransactionHelper = jest.spyOn(oInternalEditFlow, "getTransactionHelper");
+			spyGetTransactionHelper.mockImplementation(() => {
+				return oTransactionHelper;
+			});
+			spySetEditMode = jest.spyOn(oInternalEditFlow, "setEditMode");
+			spySetEditMode.mockImplementation(() => undefined);
+			spyGetView = jest.spyOn(oInternalEditFlow, "getView");
+			spyGetView.mockImplementation(() => {
+				return mockGetModel;
+			});
+			oInternalEditFlow.fnHandleSessionTimeout = true;
+			oInternalEditFlow.fnStickyDiscardAfterNavigation = undefined;
+		});
+		beforeEach(() => {});
+		afterEach(() => {
+			jest.clearAllMocks();
+		});
+		it("handleStickyOff: appComponent is undefined", oTestReferences, async () => {
+			oInternalEditFlow.fnDirtyStateProvider = true;
+			spyGetAppComponent.mockImplementation(() => {
+				return undefined;
+			});
+			const bResponse = await oInternalEditFlow.handleStickyOff();
+			expect(bResponse).toEqual(undefined);
+			expect(spyDiscardNavigationGuard).toHaveBeenCalledTimes(0);
+		});
+		it("handleStickyOff: valid function call, all set correctly", oTestReferences, async () => {
+			oInternalEditFlow.fnDirtyStateProvider = true;
+			spyGetAppComponent.mockImplementation(() => {
+				return mockGetAppComponent;
+			});
+			const bResponse = await oInternalEditFlow.handleStickyOff();
+			expect(bResponse).toEqual(true);
+			expect(spySetEditMode).toHaveBeenCalledTimes(1);
+			expect(spyGetAppComponent).toHaveBeenCalledTimes(1);
+			expect(spyDiscardNavigationGuard).toHaveBeenCalledTimes(1);
+			expect(spyDeregisterDirtyStateProvider).toHaveBeenCalledTimes(1);
+		});
+		it("handleStickyOff: fnDirtyStateProvider not set", oTestReferences, async () => {
+			oInternalEditFlow.fnDirtyStateProvider = false;
+			spyGetAppComponent.mockImplementation(() => {
+				return mockGetAppComponent;
+			});
+			const bResponse = await oInternalEditFlow.handleStickyOff();
+			expect(bResponse).toEqual(true);
+			expect(spySetEditMode).toHaveBeenCalledTimes(1);
+			expect(spyGetAppComponent).toHaveBeenCalledTimes(1);
+			expect(spyDiscardNavigationGuard).toHaveBeenCalledTimes(1);
+			expect(spyDeregisterDirtyStateProvider).toHaveBeenCalledTimes(0);
+		});
+	});
+});

package/packages/sap.fe.core/test/sap/fe/core/jest/controllerextensions/InternalRouting.spec.ts

@@ -1,3 +1,4 @@
+import BusyLocker from "sap/fe/core/BusyLocker";
 import { InternalRouting } from "sap/fe/core/controllerextensions";
 import { MockContext, MockContextBinding, MockListBinding, MockMetaModel, MockModel } from "sap/fe/test/UI5MockHelper";
 
@@ -418,3 +419,92 @@ describe("InternalRouting - #bindPage", () => {
 		});
 	});
 });
+
+describe("InternalRouting - #_dataReceivedEventHandler", () => {
+	let routingExtension: TestableInternalRouting;
+	let libraryResourceBundleMock: any, busyUnLockMock, showMessagesMock: any;
+	beforeEach(async function() {
+		routingExtension = new TestableInternalRouting();
+		(routingExtension as any).base = {
+			messageHandler: {
+				showMessages: function() {
+					return null;
+				}
+			}
+		};
+		libraryResourceBundleMock = jest.spyOn(sap.ui.getCore() as any, "getLibraryResourceBundle");
+		busyUnLockMock = jest.spyOn(BusyLocker, "unlock");
+		busyUnLockMock.mockReturnValue(true);
+		showMessagesMock = jest.spyOn((routingExtension as any).base.messageHandler, "showMessages");
+		showMessagesMock.mockReturnValue(true);
+	});
+
+	it("calls _dataReceivedEventHandler with error status as 503", async () => {
+		libraryResourceBundleMock.mockResolvedValue({
+			getText: function() {
+				return "Error";
+			}
+		});
+		const oEvent = {
+			getParameter: function() {
+				return {
+					status: 503
+				};
+			}
+		};
+		await (routingExtension as any)._dataReceivedEventHandler(oEvent);
+		expect(showMessagesMock).toHaveBeenCalledWith({ isInitialLoad503Error: true, shellBack: true });
+	});
+
+	it("calls _dataReceivedEventHandler without error status as 503", async () => {
+		libraryResourceBundleMock.mockResolvedValue({
+			getText: function() {
+				return "Error";
+			}
+		});
+		const oEvent = {
+			getParameter: function() {
+				return {
+					status: 404
+				};
+			}
+		};
+		await (routingExtension as any)._dataReceivedEventHandler(oEvent);
+		expect(showMessagesMock).toHaveBeenCalledWith({
+			title: "Error",
+			description: { status: 404 },
+			isDataReceivedError: true,
+			shellBack: true
+		});
+	});
+
+	it("calls _dataReceivedEventHandler without sErrorDescription", async () => {
+		libraryResourceBundleMock.mockResolvedValue({
+			getText: function() {
+				return "Error";
+			}
+		});
+		const oEvent = {
+			getParameter: function() {
+				return null;
+			}
+		};
+		await (routingExtension as any)._dataReceivedEventHandler(oEvent);
+		expect(showMessagesMock).toHaveBeenCalledTimes(0);
+	});
+	it("calls _dataReceivedEventHandler getLibraryResourceBundle call rejected", async () => {
+		libraryResourceBundleMock.mockImplementation(() => {
+			return Promise.reject();
+		});
+		const oEvent = {
+			getParameter: function() {
+				return null;
+			}
+		};
+		try {
+			await (routingExtension as any)._dataReceivedEventHandler(oEvent);
+		} catch {
+			expect(showMessagesMock).toHaveBeenCalledTimes(0);
+		}
+	});
+});