@sap/open.fe 1.99.0 → 1.100.0

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

@@ -2,7 +2,10 @@ import EditFlow from "sap/fe/core/controllerextensions/EditFlow";
 import TransactionHelper from "sap/fe/core/TransactionHelper";
 import CommonUtils from "sap/fe/core/CommonUtils";
 import EditState from "sap/fe/core/helpers/EditState";
-import { InternalEditFlow } from "sap/fe/core/controllerextensions";
+import InternalEditFlow from "sap/fe/core/controllerextensions/InternalEditFlow";
+import messageHandling from "sap/fe/core/actions/messageHandling";
+import coreLibrary from "sap/fe/core/library";
+import BusyLocker from "sap/fe/core/BusyLocker";
 
 describe("EditFlow ControllerExtension", function() {
 	describe("editDocument - onBeforeEdit", () => {
@@ -15,7 +18,7 @@ describe("EditFlow ControllerExtension", function() {
 			oEditDocumentMock: any;
 		beforeEach(() => {
 			oEditFlow = new EditFlow();
-			oTransactionHelper = new TransactionHelper(null, null);
+			oTransactionHelper = new TransactionHelper(null as any, null);
 			oGetTransactionHelperMock = jest.spyOn(oEditFlow, "_getTransactionHelper");
 			oGetTransactionHelperMock.mockImplementation(() => {
 				return oTransactionHelper;
@@ -80,7 +83,7 @@ describe("EditFlow ControllerExtension", function() {
 			oSaveDocumentMock: any;
 		beforeEach(() => {
 			oEditFlow = new EditFlow();
-			oTransactionHelper = new TransactionHelper(null, null);
+			oTransactionHelper = new TransactionHelper(null as any, null);
 			oGetTransactionHelperMock = jest.spyOn(oEditFlow, "_getTransactionHelper");
 			oGetTransactionHelperMock.mockImplementation(() => {
 				return oTransactionHelper;
@@ -157,7 +160,143 @@ describe("EditFlow ControllerExtension", function() {
 			}
 		});
 	});
+
+	describe("invokeAction - _getActionOverloadContextFromSubSections", () => {
+		let oEditFlow: any;
+
+		const mockGetMetaContext1 = { getObject: jest.fn().mockReturnValue("com.c_salesordermanage_sd.SalesOrderManage") };
+		const mockGetMetaContext2 = { getObject: jest.fn().mockReturnValue("com.c_salesordermanage_sd.HeaderShipToParty") };
+		const mockGetMetaModel1 = { getMetaContext: jest.fn().mockReturnValue(mockGetMetaContext1) };
+		const mockGetMetaModel2 = { getMetaContext: jest.fn().mockReturnValue(mockGetMetaContext2) };
+		const mockGetModel1 = { getMetaModel: jest.fn().mockReturnValue(mockGetMetaModel1) };
+		const mockGetModel2 = { getMetaModel: jest.fn().mockReturnValue(mockGetMetaModel2) };
+		const mockGetPath: string = "dummy";
+		const mockGetBindingContext1 = {
+			getModel: jest.fn().mockReturnValue(mockGetModel1),
+			getPath: jest.fn().mockReturnValue(mockGetPath)
+		};
+		const mockGetBindingContext2 = {
+			getModel: jest.fn().mockReturnValue(mockGetModel2),
+			getPath: jest.fn().mockReturnValue(mockGetPath)
+		};
+
+		const mockActionsSet1 = [
+			{
+				getBindingContext: jest.fn().mockReturnValue(mockGetBindingContext1),
+				getParent: jest.fn(),
+				isA: jest.fn(function(name: string) {
+					return name === "sap.m.Button";
+				})
+			},
+			{
+				getBindingContext: jest.fn().mockReturnValue(mockGetBindingContext2),
+				getParent: jest.fn(),
+				isA: jest.fn(function(name: string) {
+					return name === "sap.m.Button";
+				})
+			}
+		];
+		const mockActionsSet2 = [
+			{
+				getBindingContext: jest.fn().mockReturnValue(mockGetBindingContext1),
+				getParent: jest.fn(),
+				isA: jest.fn(function(name: string) {
+					return name === "sap.m.Button";
+				})
+			}
+		];
+
+		const mockSubSections = [
+			{
+				actions: mockActionsSet1,
+				getParent: jest.fn(),
+				getAggregation: jest.fn().mockReturnValue(mockActionsSet1),
+				isA: jest.fn(function(name: string) {
+					return name === "sap.uxap.ObjectPageSubSection";
+				})
+			},
+			{
+				actions: mockActionsSet2,
+				getParent: jest.fn(),
+				getAggregation: jest.fn().mockReturnValue(mockActionsSet2),
+				isA: jest.fn(function(name: string) {
+					return name === "sap.uxap.ObjectPageSubSection";
+				})
+			}
+		];
+
+		const mockObjectPageSection: any = {
+			subSections: mockSubSections,
+			getAggregation: jest.fn().mockReturnValue(mockSubSections),
+			isA: jest.fn(function(name: string) {
+				return name === "sap.uxap.ObjectPageSection";
+			})
+		};
+
+		beforeAll(() => {
+			mockActionsSet1[0].getParent.mockReturnValue(mockSubSections[0]);
+			mockActionsSet1[1].getParent.mockReturnValue(mockSubSections[0]);
+			mockActionsSet2[0].getParent.mockReturnValue(mockSubSections[1]);
+			mockSubSections[0].getParent.mockReturnValue(mockObjectPageSection);
+			mockSubSections[1].getParent.mockReturnValue(mockObjectPageSection);
+		});
+
+		beforeEach(() => {
+			oEditFlow = new EditFlow();
+		});
+
+		afterEach(() => {
+			jest.clearAllMocks();
+		});
+
+		it("Input parameter oControl is undefined", async () => {
+			const bResponse = await oEditFlow._getActionOverloadContextFromSubSections(undefined);
+			expect(bResponse).toEqual(undefined);
+		});
+		it("Context searched not available", async () => {
+			mockActionsSet1[1].getBindingContext.mockReturnValue(mockGetBindingContext1);
+			const bResponse = await oEditFlow._getActionOverloadContextFromSubSections(
+				mockActionsSet1[0],
+				"com.c_salesordermanage_sd.HeaderShipToParty"
+			);
+			expect(bResponse).toBeUndefined;
+		});
+		it("Called with invalid context", async () => {
+			mockActionsSet1[1].getBindingContext.mockReturnValue(mockGetBindingContext2);
+			const bResponse = await oEditFlow._getActionOverloadContextFromSubSections(
+				mockActionsSet2[0],
+				"com.c_salesordermanage_sd.Dummy"
+			);
+			expect(bResponse).toEqual(undefined);
+		});
+		it("Input parameter oControl is defined", async () => {
+			mockActionsSet1[1].getBindingContext.mockReturnValue(mockGetBindingContext2);
+			const bResponse = await oEditFlow._getActionOverloadContextFromSubSections(
+				mockActionsSet1[0],
+				"com.c_salesordermanage_sd.HeaderShipToParty"
+			);
+			expect(bResponse).toBeDefined();
+		});
+		it("Called from second SubSection", async () => {
+			mockActionsSet1[1].getBindingContext.mockReturnValue(mockGetBindingContext2);
+			const bResponse = await oEditFlow._getActionOverloadContextFromSubSections(
+				mockActionsSet2[0],
+				"com.c_salesordermanage_sd.HeaderShipToParty"
+			);
+			expect(bResponse).toBeDefined();
+		});
+		it("Context found on last SubSection", async () => {
+			mockActionsSet1[1].getBindingContext.mockReturnValue(mockGetBindingContext1);
+			mockActionsSet2[0].getBindingContext.mockReturnValue(mockGetBindingContext2);
+			const bResponse = await oEditFlow._getActionOverloadContextFromSubSections(
+				mockActionsSet2[0],
+				"com.c_salesordermanage_sd.HeaderShipToParty"
+			);
+			expect(bResponse).toBeDefined();
+		});
+	});
 });
+
 describe("deleteDocument - onBeforeDelete", () => {
 	let oEditFlow: any, oInternalEditFlow: any, oDeleteMultipleDocumentsMock: any;
 	let oGetAppComponentMock, oGetViewMock, oDeleteDocumentTransactionMock: any, oSetEditStateDirty, oGetRoutingListenerMock;
@@ -165,7 +304,7 @@ describe("deleteDocument - onBeforeDelete", () => {
 		oEditFlow = new EditFlow();
 		oInternalEditFlow = new InternalEditFlow();
 		oGetAppComponentMock = jest.spyOn(CommonUtils, "getAppComponent");
-		oGetAppComponentMock.mockImplementation(() => undefined);
+		oGetAppComponentMock.mockImplementation(() => undefined as any);
 		oGetViewMock = jest.spyOn(oEditFlow, "getView");
 		oGetViewMock.mockImplementation(() => {
 			return {
@@ -213,7 +352,10 @@ describe("deleteDocument - onBeforeDelete", () => {
 
 	it("check if onBeforeDelete is passed as a callback for single context delete", async () => {
 		const oContext = {
-			"SalesOrder": "6437"
+			"SalesOrder": "6437",
+			getPath: function() {
+				return "/SalesOrder(6437)";
+			}
 		};
 		const mParameters = {
 			bFindActiveContexts: false,
@@ -243,3 +385,524 @@ describe("deleteDocument - onBeforeDelete", () => {
 		expect(oDeleteMultipleDocumentsMock).toBeCalledWith(aContexts, mParameters);
 	});
 });
+describe("Tests for EditFlow", function() {
+	const CreationMode = coreLibrary.CreationMode;
+	const mockValidationDocument = jest.fn();
+	let oMessageHandlingStub!: any;
+	let oWindowStub!: any;
+	let mParameters!: any;
+	let oEditFlow!: any;
+	let oInternalEditFlow!: any;
+	beforeEach(() => {
+		oEditFlow = new EditFlow();
+		oInternalEditFlow = new InternalEditFlow();
+		mockValidationDocument.mockReset();
+
+		oInternalEditFlow.getTransactionHelper = function() {
+			return {
+				deleteDocument: function() {
+					return Promise.resolve();
+				},
+				editDocument: function() {
+					return Promise.resolve();
+				},
+				getProgrammingModel: function() {
+					return Promise.resolve("Draft");
+				},
+				saveDocument: function() {
+					return Promise.resolve();
+				},
+				cancelDocument: function() {
+					return Promise.resolve(true);
+				},
+				createDocument: function() {
+					return Promise.resolve({
+						getPath: function() {
+							return "newPath";
+						}
+					});
+				},
+				validateDocument: mockValidationDocument,
+				getText: function(sText: string) {
+					return sText;
+				},
+				oLockObject: {
+					setProperty: jest.fn(),
+					getProperty: jest.fn()
+				}
+			};
+		};
+
+		oInternalEditFlow.getRoutingListener = function() {
+			return {
+				navigateToContext: function() {
+					return Promise.resolve();
+				},
+				navigateBackFromContext: function() {
+					return Promise.resolve();
+				},
+				navigateForwardToContext: function() {
+					return Promise.resolve();
+				}
+			};
+		};
+		oEditFlow.getView = function() {
+			return {
+				getRouterProxy: function() {
+					return {
+						removeIAppStateKey: function() {}
+					};
+				},
+				getShellServices: function() {
+					return {
+						setBackNavigation: function() {}
+					};
+				},
+				isA: function() {
+					return "sap.fe.core.AppComponent";
+				},
+				getController: function() {
+					return {
+						_editFlow: oInternalEditFlow,
+						oResourceBundle: undefined
+					};
+				},
+				getBindingContext: function() {
+					return [];
+				},
+				getModel: function() {
+					return {
+						getProperty: function() {
+							return false;
+						}
+					};
+				}
+			};
+		};
+		oInternalEditFlow.getView = function() {
+			return {
+				getController: function() {
+					return {
+						editFlow: oEditFlow
+					};
+				},
+				getModel: function() {
+					return {
+						setProperty: jest.fn(),
+						attachSessionTimeout: function() {},
+						getId: function() {
+							return "dummy";
+						}
+					};
+				}
+			};
+		};
+		oInternalEditFlow.getMessageHandler = function() {
+			return {
+				showMessageDialog: function() {
+					return Promise.resolve();
+				},
+				removeTransitionMessages: function() {
+					return Promise.resolve();
+				}
+			};
+		};
+
+		oEditFlow.getLockObject = function() {
+			return {
+				setProperty: jest.fn(),
+				getProperty: jest.fn()
+			};
+		};
+
+		oEditFlow._getInternalModel = function() {
+			return {
+				setProperty: jest.fn(),
+				getProperty: jest.fn()
+			};
+		};
+
+		oEditFlow._removeContextsFromPages = function() {};
+		oEditFlow.base = {
+			getView: oEditFlow.getView,
+			editFlow: {
+				onBeforeSave: function() {
+					return Promise.resolve();
+				},
+				onBeforeDelete: function() {
+					return Promise.resolve();
+				},
+				onBeforeEdit: function() {
+					return Promise.resolve();
+				},
+				onBeforeCreate: function() {
+					return Promise.resolve();
+				},
+				onBeforeDiscard: function() {
+					return Promise.resolve();
+				}
+			}
+		};
+		oInternalEditFlow.base = {
+			getView: oInternalEditFlow.getView
+		};
+
+		oMessageHandlingStub = jest.spyOn(messageHandling, "showUnboundMessages").mockReturnValue({} as any);
+		oWindowStub = jest.spyOn(window.history, "back").mockReturnValue(true as any);
+		mParameters = {
+			creationMode: "CreationRow",
+			creationRow: {
+				getParent: function() {
+					// the table
+					return {
+						getCreationRow: function() {
+							return {
+								data: function() {
+									return "functionPath.functionName";
+								}
+							};
+						},
+						getBindingContext: function() {
+							return {
+								getProperty: function() {
+									return {};
+								}
+							};
+						},
+						isA: function() {
+							return false;
+						}
+					};
+				},
+				getBindingContext: function() {
+					return {
+						getObject: function() {
+							return {};
+						}
+					};
+				}
+			}
+		};
+	});
+	afterEach(() => {
+		oMessageHandlingStub.mockRestore();
+		oWindowStub.mockRestore();
+	});
+
+	test("Create Document fails without binding", function() {
+		const vListBinding = null;
+		expect(oEditFlow.createDocument(vListBinding, {})).rejects.toEqual({});
+	});
+
+	test("Create Document", function() {
+		const fnGetImmutable = CommonUtils.getNonComputedVisibleFields;
+		CommonUtils.getNonComputedVisibleFields = function() {
+			return [];
+		};
+		const vListBinding = {
+			getModel: function() {
+				return {
+					getMetaModel: function() {
+						return {
+							getObject: function(sParams: any) {
+								if (sParams.indexOf("@com.sap.vocabularies.Session.v1.StickySessionSupported/NewAction") > -1) {
+									return "someNamespace.someEntityset";
+								} else if (sParams.indexOf("/someNamespace.someEntityset/@$ui5.overload/0/$Parameter") > -1) {
+									return [{}, {}];
+								}
+							},
+							getMetaPath: function() {
+								return "/somePath";
+							}
+						};
+					}
+				};
+			},
+			isRelative: function() {
+				return false;
+			},
+			getPath: function() {
+				return "";
+			},
+			getHeaderContext: function() {
+				return {
+					getPath: function() {
+						return "/somePath";
+					}
+				};
+			}
+		};
+		return oEditFlow.createDocument(vListBinding, {}).then(function(result: any) {
+			CommonUtils.getNonComputedVisibleFields = fnGetImmutable;
+		});
+	});
+
+	Object.keys(CreationMode).forEach(function(sKey) {
+		const sCreationMode = CreationMode[sKey];
+		test("Create Document BusyLocker call behavior for creationMode=" + sCreationMode, function() {
+			const fnGetImmutable = CommonUtils.getNonComputedVisibleFields;
+			const oBusyLockSpy = jest.spyOn(BusyLocker, "lock"),
+				oBusyUnlockSpy = jest.spyOn(BusyLocker, "unlock"),
+				iExpectedBusyLockerCallCount =
+					sCreationMode === CreationMode.Inline ||
+					sCreationMode === CreationMode.CreationRow ||
+					sCreationMode === CreationMode.External
+						? 0
+						: 1;
+
+			// we are not interested in the actual execution of editFlow, so let the syncTask fail
+			jest.spyOn(oEditFlow, "_syncTask").mockReturnValue(Promise.reject({ message: "Fail early, fail often" }));
+
+			return oEditFlow.createDocument(null, { creationMode: sCreationMode }).catch(function() {
+				expect(oBusyLockSpy).toHaveBeenCalledTimes(iExpectedBusyLockerCallCount); //"BusyLocker.lock was called " + oBusyLockSpy.callCount + "/" + iExpectedBusyLockerCallCount + " times!"
+				expect(oBusyUnlockSpy).toHaveBeenCalledTimes(iExpectedBusyLockerCallCount); // "BusyLocker.unlock was called " + oBusyUnlockSpy.callCount + "/" + iExpectedBusyLockerCallCount + " times!"
+				CommonUtils.getNonComputedVisibleFields = fnGetImmutable;
+				oBusyLockSpy.mockRestore();
+				oBusyUnlockSpy.mockRestore();
+			});
+		});
+	});
+
+	test(
+		"Create Document with failing Validation",
+		{
+			"references": [
+				{
+					"type": "JIRA",
+					"ID": "FIORITECHP1-20745"
+				}
+			]
+		},
+		function() {
+			const oMessageHandlerSpy = jest.spyOn(oEditFlow, "_getMessageHandler");
+
+			// validationWrapper return an array, i.e. a validation error occurred
+			mockValidationDocument.mockImplementation(() => {
+				return Promise.resolve([{ messageText: "Validation failed" }]);
+			});
+
+			return oEditFlow
+				.createDocument({}, mParameters)
+				.then(function() {
+					expect(mockValidationDocument).toHaveBeenCalledTimes(1); // "validationWrapper was called once");
+					expect(oMessageHandlerSpy).toHaveBeenCalledTimes(1); // "Message Handler for error message called once");
+				})
+				.finally(function() {
+					oMessageHandlerSpy.mockRestore();
+				});
+		}
+	);
+
+	test(
+		"Create Document with positive Validation",
+		{
+			"references": [
+				{
+					"type": "JIRA",
+					"ID": "FIORITECHP1-20745"
+				}
+			]
+		},
+		function() {
+			const oMessageHandlerSpy = jest.spyOn(oEditFlow, "_getMessageHandler");
+
+			// validationWrapper returns empty array indicating no error in validation
+			mockValidationDocument.mockReturnValue([]);
+
+			return oEditFlow
+				.createDocument({}, mParameters)
+				.catch(function() {
+					expect(mockValidationDocument).toHaveBeenCalledTimes(1); // "validationWrapper was called once");
+					expect(oMessageHandlerSpy).toHaveBeenCalledTimes(0); //, "No error message was shown");
+				})
+				.finally(function() {
+					oMessageHandlerSpy.mockRestore();
+				});
+		}
+	);
+
+	test("ApplyDocument - Shall resolve the promise if apply is successful", function() {
+		const oContext = {
+				getModel: jest.fn().mockReturnValue({
+					submitBatch: jest.fn().mockReturnValue(Promise.resolve()),
+					hasPendingChanges: jest.fn().mockReturnValue(false)
+				}),
+				getBinding: jest.fn().mockReturnValue({
+					getUpdateGroupId: jest.fn().mockReturnValue("$auto"),
+					hasPendingChanges: jest.fn().mockReturnValue(false)
+				})
+			},
+			oValidationErrorsStub = jest.spyOn(oEditFlow, "_checkForValidationErrors").mockReturnValue(true);
+
+		return oEditFlow
+			.applyDocument(oContext)
+			.then(function() {
+				expect(true).toBe(true); // "Promise is resolved after apply call");
+			})
+			.finally(function() {
+				oValidationErrorsStub.mockRestore();
+			});
+	});
+
+	test("ApplyDocument - Shall reject if validation errors exist", function() {
+		const oContext = {
+				getModel: jest.fn().mockReturnValue({
+					submitBatch: jest.fn().mockReturnValue(Promise.resolve()),
+					hasPendingChanges: jest.fn().mockReturnValue(false)
+				}),
+				getBinding: jest.fn().mockReturnValue({
+					getUpdateGroupId: jest.fn().mockReturnValue("$auto"),
+					hasPendingChanges: jest.fn().mockReturnValue(false)
+				})
+			},
+			oValidationErrorsStub = jest.spyOn(oEditFlow, "_checkForValidationErrors").mockReturnValue(Promise.reject());
+
+		return expect(oEditFlow.applyDocument(oContext))
+			.rejects.toEqual(undefined)
+			.finally(function() {
+				oValidationErrorsStub.mockRestore();
+			});
+	});
+
+	test("ApplyDocument - Shall reject the promise if apply is failed", function() {
+		const oContext = {
+				getModel: jest.fn().mockReturnValue({
+					submitBatch: jest.fn().mockRejectedValue({})
+				})
+			},
+			oValidationErrorsStub = jest.spyOn(oEditFlow, "_checkForValidationErrors").mockReturnValue(true);
+
+		return expect(oEditFlow.applyDocument(oContext))
+			.rejects.toEqual({})
+			.finally(function() {
+				oValidationErrorsStub.mockRestore();
+			});
+	});
+
+	test("ApplyDocument - Shall reject if after apply there are still pending changes", function() {
+		const oContext = {
+				getModel: jest.fn().mockReturnValue({
+					submitBatch: jest.fn().mockReturnValue(Promise.resolve()),
+					hasPendingChanges: jest.fn().mockReturnValue(true)
+				})
+			},
+			oValidationErrorsStub = jest.spyOn(oEditFlow, "_checkForValidationErrors").mockReturnValue(true);
+
+		return expect(oEditFlow.applyDocument(oContext))
+			.rejects.toEqual("submit of open changes failed")
+			.finally(function() {
+				oValidationErrorsStub.mockRestore();
+			});
+	});
+
+	test("DeleteDocument - Should not throw any error if delete is successful", function() {
+		const oContext = {
+			getPath: function() {
+				return "anyPath";
+			}
+		};
+		return oEditFlow.deleteDocument(oContext).then(function(result: any) {
+			expect(!result).toBe(true); //, "Success after delete call");
+		});
+	});
+
+	test("Edit Document", function() {
+		const oContext = {};
+		const result = oEditFlow.editDocument(oContext);
+
+		expect(result instanceof Promise).toBe(true); //assert.ok(result instanceof Promise, "Result is a promise");
+		return result;
+	});
+
+	test("UpdateDocument - Shall resolve the promise if update document is successful", function() {
+		const oContext = {
+			getModel: jest.fn().mockReturnValue({
+				submitBatch: jest.fn().mockReturnValue(Promise.resolve()),
+				hasPendingChanges: jest.fn().mockReturnValue(false)
+			}),
+			getBinding: jest.fn().mockReturnValue({
+				getUpdateGroupId: jest.fn().mockReturnValue("$auto"),
+				hasPendingChanges: jest.fn().mockReturnValue(false)
+			})
+		};
+		return oEditFlow.updateDocument(oContext);
+	});
+
+	// QUnit.test("Save Document", function(assert) {
+	// 	var oContext = {
+	// 		getModel: sinon.stub().returns({
+	// 			submitBatch: sinon.stub().returns(Promise.resolve()),
+	// 			hasPendingChanges: sinon.stub().returns(false)
+	// 		})
+	// 	};
+	// 	var result = oEditFlow.saveDocument(oContext);
+	//
+	// 	assert.ok(result instanceof Promise, "Result is a promise");
+	// 	return result.then(function(arg) {
+	// 		assert.ok(true, "Success after save call");
+	// 	}).catch(function(oError) {
+	// 		assert.ok(false);
+	// 	});
+	// });
+
+	test("Cancel Document", function() {
+		const oContext = {};
+		oEditFlow._fetchSemanticKeyValues = function() {
+			return Promise.resolve(true);
+		};
+		const oCancelButton = { cancelButton: "fe::FooterBar::StandardAction::Cancel" };
+		return oEditFlow.cancelDocument(oContext, oCancelButton).then(function(result: any) {
+			expect(!result).toBe(true); //, "Success after delete call");
+		});
+	});
+
+	test("Secured Execution default settings", function() {
+		let bMyFunctionCalled: boolean;
+
+		return oEditFlow
+			.securedExecution(function() {
+				bMyFunctionCalled = true;
+				return Promise.resolve();
+			})
+			.then(function() {
+				expect(bMyFunctionCalled).toBe(true);
+			});
+	});
+
+	test("Secured Execution in busy state with check", function() {
+		oEditFlow.securedExecution(function() {
+			return Promise.resolve();
+		});
+
+		return expect(
+			oEditFlow.securedExecution(function() {
+				return Promise.resolve();
+			})
+		).rejects.toEqual("Application already busy therefore execution rejected");
+	});
+
+	test("Secured Execution in busy state without busy check", function() {
+		let bMySecondFunctionCalled: boolean;
+
+		oEditFlow.securedExecution(function() {
+			return Promise.resolve();
+		});
+
+		return oEditFlow
+			.securedExecution(
+				function() {
+					bMySecondFunctionCalled = true;
+					return Promise.resolve();
+				},
+				{
+					busy: {
+						set: true,
+						check: false
+					}
+				}
+			)
+			.then(function() {
+				expect(bMySecondFunctionCalled).toBe(true); //, "My 2nd function was called as busy check deactivated");
+			});
+	});
+});