@sap/open.fe 1.98.0 → 1.99.0

package/packages/sap.fe.templates/test/sap/fe/templates/jest/ListReport/overrides/ViewState.spec.ts

@@ -0,0 +1,442 @@
+import { mockMVC, MVCMock } from "@sap-ux/jest-mock-ui5/dist/mvc";
+import Controller from "sap/ui/core/mvc/Controller";
+import View from "sap/ui/core/mvc/View";
+import CommonUtils from "sap/fe/core/CommonUtils";
+import PageController from "sap/fe/core/PageController";
+import { ListReportControllerType, mockFilterBar, mockListReportController, mockContextForExtension } from "sap/fe/test/FeMocks";
+import { ViewState as ViewStateOverrides, ViewStateType } from "sap/fe/templates/ListReport/overrides";
+import { mock, WithMock } from "@sap-ux/jest-mock-ui5/dist/generic";
+import Table from "sap/ui/mdc/Table";
+import VariantManagement from "sap/ui/fl/variants/VariantManagement";
+import ControlVariantApplyAPI from "sap/ui/fl/apply/api/ControlVariantApplyAPI";
+import { ViewState } from "sap/fe/core/controllerextensions";
+import KeepAliveHelper from "sap/fe/core/helpers/KeepAliveHelper";
+import Control from "sap/ui/core/Control";
+import ModelHelper from "sap/fe/core/helpers/ModelHelper";
+import { FilterUtils } from "sap/fe/macros/filter";
+import * as PropertyFormatters from "sap/fe/core/templating/PropertyFormatters";
+import { DelegateUtil } from "sap/fe/macros";
+import StateUtil from "sap/ui/mdc/p13n/StateUtil";
+import ODataModel from "sap/ui/model/odata/v4/ODataModel";
+
+let app!: MVCMock<ODataModel, View, ListReportControllerType & PageController & Controller>;
+let viewState!: WithMock<ViewStateType & ViewState>;
+
+describe("overrides/ViewState", () => {
+	beforeAll(() => {
+		// mock FE app around the controller extension ViewState
+		const controller = mockListReportController();
+		app = mockMVC(controller, View, ODataModel);
+		viewState = mockContextForExtension(ViewStateOverrides, controller, ViewState);
+		// mock calls to ViewState base
+		viewState.mock._checkIfVariantIdIsAvailable.mockReturnValue(true);
+	});
+
+	describe("applyInitialStateOnly", () => {
+		test("empty method that always returns true", () => {
+			expect(viewState.applyInitialStateOnly()).toBe(true);
+		});
+	});
+
+	describe("onBeforeStateApplied", () => {
+		const filterBar = mockFilterBar();
+		const table = mock(Table);
+
+		beforeEach(() => {
+			filterBar.mock.initialized.mockReset();
+			table.mock.initialized.mockReset();
+		});
+
+		test("with FilterBar and tables", () => {
+			app.controller.mock._getFilterBarControl.mockReturnValueOnce(filterBar);
+			app.controller.mock._getControls.mockReturnValueOnce([table]);
+			const promises: unknown[] = [];
+			viewState.onBeforeStateApplied(promises);
+			expect(promises.length).toBe(2);
+			expect(filterBar.initialized).toBeCalled();
+			expect(table.initialized).toBeCalled();
+		});
+
+		test("only FilterBar", () => {
+			app.controller.mock._getFilterBarControl.mockReturnValueOnce(filterBar);
+			app.controller.mock._getControls.mockReturnValueOnce([]);
+			const promises: unknown[] = [];
+			viewState.onBeforeStateApplied(promises);
+			expect(promises.length).toBe(1);
+			expect(filterBar.initialized).toBeCalled();
+		});
+
+		test("only tables", () => {
+			app.controller.mock._getFilterBarControl.mockReturnValueOnce(undefined);
+			app.controller.mock._getControls.mockReturnValueOnce([table, table]);
+			const promises: unknown[] = [];
+			viewState.onBeforeStateApplied(promises);
+			expect(promises.length).toBe(2);
+			expect(table.initialized).toBeCalledTimes(2);
+		});
+
+		test("nothing to be initialized", () => {
+			app.controller.mock._getFilterBarControl.mockReturnValueOnce(undefined);
+			app.controller.mock._getControls.mockReturnValueOnce([]);
+			const promises: unknown[] = [];
+			viewState.onBeforeStateApplied(promises);
+			expect(promises.length).toBe(0);
+		});
+	});
+
+	describe("onAfterStateApplied", () => {
+		const filterBar = mockFilterBar();
+
+		beforeEach(() => {
+			filterBar.mock.setSuspendSelection.mockReset();
+			app.controller.mock._isFilterBarHidden.mockReset();
+		});
+
+		test("no FilterBar", () => {
+			app.controller.mock._getFilterBarControl.mockReturnValueOnce(undefined);
+			app.controller.mock._isFilterBarHidden.mockReturnValueOnce(false);
+			viewState.onAfterStateApplied();
+			expect(filterBar.mock.setSuspendSelection).not.toBeCalled();
+		});
+
+		test("visible FilterBar", () => {
+			app.controller.mock._getFilterBarControl.mockReturnValueOnce(filterBar);
+			viewState.onAfterStateApplied();
+			expect(filterBar.mock.setSuspendSelection).toBeCalled();
+		});
+
+		test("hidden FilterBar", () => {
+			app.controller.mock._getFilterBarControl.mockReturnValue(undefined);
+			app.controller.mock._isFilterBarHidden.mockReturnValue(true);
+			const mockContext = { setProperty: jest.fn() };
+			app.view.mock.getBindingContext.mockReturnValue(mockContext);
+
+			app.controller.mock._isMultiMode.mockReturnValueOnce(false);
+			viewState.onAfterStateApplied();
+			expect(mockContext.setProperty).toBeCalledWith("hasPendingFilters", false);
+
+			app.controller.mock._isMultiMode.mockReturnValueOnce(true);
+			app.controller.mock._getControls.mockReturnValueOnce([]);
+			app.controller.mock._getCurrentControl.mockReturnValueOnce({ getId: () => "" });
+			viewState.onAfterStateApplied();
+			expect(mockContext.setProperty).toBeCalledWith("hasPendingFilters", false);
+			expect(app.controller._setCountsOutDated).toBeCalled();
+		});
+	});
+
+	describe("adaptBindingRefreshControls", () => {
+		test("controls are added", () => {
+			jest.spyOn(KeepAliveHelper, "getControlsForRefresh").mockImplementation(() => [mock(Control)]);
+			const controls: Control[] = [];
+			viewState.adaptBindingRefreshControls(controls);
+			expect(controls.length).toBe(1);
+		});
+	});
+
+	describe("adaptStateControls", () => {
+		const vm = mock(VariantManagement);
+		const filterBar = mockFilterBar();
+
+		beforeAll(() => {
+			app.view.mock.byId.mockImplementation((id: string) => {
+				const control = mock(Control);
+				control.mock.getId.mockReturnValue(id);
+				return control;
+			});
+		});
+
+		test("only the page", () => {
+			app.view.mock.getViewData.mockReturnValue({ variantManagement: "None" });
+			app.controller.mock._getControls.mockReturnValueOnce([]);
+
+			const controls: Control[] = [];
+			viewState.adaptStateControls(controls);
+			expect(controls.length).toBe(1);
+			expect(controls[0].getId()).toBe("fe::ListReport");
+		});
+
+		test("with filter bar", () => {
+			app.view.mock.getViewData.mockReturnValue({ variantManagement: "None" });
+			app.controller.mock._getControls.mockReturnValueOnce([]);
+			app.controller.mock._getFilterBarControl.mockReturnValueOnce(filterBar);
+
+			const controls: Control[] = [];
+			viewState.adaptStateControls(controls);
+			expect(controls.length).toBe(2);
+			expect(controls[0]).toBe(filterBar);
+			expect(controls[1].getId()).toBe("fe::ListReport");
+		});
+
+		test("isMultiNode & control variant management", () => {
+			// multinode
+			app.controller.mock._isMultiMode.mockReturnValue(true);
+			const mnControl = mock(Control);
+			app.controller.mock._getMultiModeControl.mockReturnValueOnce(mnControl);
+
+			// tables
+			app.controller.mock._getControls.mockReturnValueOnce([]);
+
+			// control variant management
+			app.view.mock.getViewData.mockReturnValue({ variantManagement: "Control" });
+			app.view.mock.getContent.mockReturnValue([{ data: (id: string) => id }]);
+
+			const controls: Control[] = [];
+			viewState.adaptStateControls(controls);
+			expect(controls.length).toBe(3);
+			// FilterBar/Page VM must be listed before IconTabBar (MultiModeControl)
+			expect(controls[0].getId()).toBe("filterBarVariantId");
+			expect(controls[1]).toBe(mnControl);
+		});
+
+		test.skip("multiple tables", () => {
+			// TODO
+		});
+	});
+
+	describe("retrieveAdditionalStates", () => {});
+
+	describe("_applySelectionVariant", () => {
+		test("no filter bar", () => {
+			const result = viewState._applySelectionVariant(app.view, { selectionVariant: {} }, true);
+			expect(result).toBeDefined();
+		});
+	});
+
+	describe("applyAdditionalStates", () => {
+		const filterBar = mockFilterBar();
+
+		test("data is not loaded", () => {
+			app.controller.mock._getFilterBarControl.mockReturnValueOnce(filterBar);
+			viewState.applyAdditionalStates({
+				dataLoaded: false
+			});
+			expect(filterBar._bSearchTriggered).toBe(false);
+		});
+
+		test("data is loaded, with filterbar", () => {
+			app.controller.mock._getFilterBarControl.mockReturnValueOnce(filterBar);
+			viewState.applyAdditionalStates({
+				dataLoaded: true
+			});
+			expect(filterBar.triggerSearch).toBeCalled();
+			expect(viewState._bSearchTriggered).toBe(true);
+		});
+	});
+
+	describe("applyNavigationParameters", () => {
+		const filterBar = mockFilterBar();
+
+		test("should add a promise to the promises parameter - without component data", () => {
+			app.controller.mock.getAppComponent.mockReturnValueOnce({
+				getComponentData: () => ({})
+			});
+			jest.spyOn(viewState, "handleVariantIdPassedViaURLParams").mockImplementation(() => Promise.resolve([]));
+			const promises: unknown[] = [];
+			viewState.applyNavigationParameters({}, promises);
+			expect(app.controller.mock.getAppComponent).toBeCalled();
+			expect(viewState.handleVariantIdPassedViaURLParams).toBeCalled();
+			expect(promises.length).toBe(1);
+		});
+		test("should add a promise to the promises parameter - with component data", () => {
+			app.controller.mock.getAppComponent.mockReturnValueOnce({
+				getComponentData: () => ({})
+			});
+			jest.spyOn(viewState, "handleVariantIdPassedViaURLParams").mockImplementation(() => Promise.resolve([]));
+			const vm = mock(VariantManagement);
+			jest.spyOn(viewState, "_getFilterBarVM").mockReturnValueOnce(vm);
+			app.controller.mock._getFilterBarControl.mockReturnValueOnce(filterBar);
+			app.view.mock.getViewData.mockReturnValue({ initialLoad: "Enabled" });
+			app.controller.mock._shouldAutoTriggerSearch.mockReturnValueOnce(true);
+
+			app.view.mock.byId.mockReturnValue({
+				setHeaderExpanded: () => jest.fn()
+			});
+
+			filterBar.mock.triggerSearch.mockImplementation(() => true);
+
+			const promises: unknown[] = [];
+			viewState.applyNavigationParameters({}, promises);
+			expect(promises.length).toBe(1);
+		});
+
+		afterEach(() => {
+			jest.restoreAllMocks();
+		});
+	});
+
+	describe("handleVariantIdPassedViaURLParams", () => {
+		const variantId = "testId";
+		const vm = mock(VariantManagement);
+
+		beforeAll(() => {
+			app.view.mock.byId.mockReturnValue(vm);
+			app.view.mock.getContent.mockReturnValue([
+				{
+					data(id: string) {
+						return id;
+					}
+				}
+			]);
+			jest.spyOn(ControlVariantApplyAPI, "activateVariant").mockResolvedValue(true);
+			vm.mock.getVariants.mockReturnValue([{ key: variantId }]);
+		});
+
+		test("Page variant", async () => {
+			app.view.mock.getViewData.mockReturnValue({ variantManagement: "Page" });
+			const results = await viewState.handleVariantIdPassedViaURLParams({ "sap-ui-fe-variant-id": [variantId] });
+			expect(results).toBeDefined();
+			expect(results[0]).toBe(true);
+		});
+
+		test("FilterBar variant", async () => {
+			app.view.mock.getViewData.mockReturnValue({ variantManagement: "Control" });
+			const results = await viewState.handleVariantIdPassedViaURLParams({ "sap-ui-fe-filterbar-variant-id": [variantId] });
+			expect(results).toBeDefined();
+			expect(results[0]).toBe(true);
+		});
+
+		test("Table variant", async () => {
+			app.view.mock.getViewData.mockReturnValue({ variantManagement: "Control" });
+			const table = mock(Table);
+			table.mock.getVariant.mockReturnValue(vm);
+			app.controller.mock._getControls.mockReturnValue([table]);
+			const results = await viewState.handleVariantIdPassedViaURLParams({ "sap-ui-fe-table-variant-id": [variantId] });
+			expect(results).toBeDefined();
+			expect(results[0]).toBe(undefined);
+		});
+	});
+
+	describe("private", () => {
+		describe("_fnApplyConditions", () => {
+			beforeAll(() => {
+				jest.spyOn(CommonUtils, "getFilterRestrictionsByPath").mockImplementation(() => {
+					return {
+						FilterAllowedExpressions: {
+							SalesOrderDate: ["SingleRange"],
+							SoldToParty: ["SingleValue"]
+						},
+						NonFilterableProperties: ["OverallSDProcessStatus"],
+						RequiredProperties: []
+					};
+				});
+				jest.spyOn(ModelHelper, "getEntitySetPath").mockImplementation(() => "/SalesOrderManage");
+				jest.spyOn(FilterUtils, "getConvertedFilterFields").mockImplementation(() => {
+					return [
+						{
+							annotationPath: "/SalesOrderManage/SalesOrder",
+							availability: "Default",
+							caseSensitive: true,
+							conditionPath: "SalesOrder",
+							group: "",
+							groupLabel: "",
+							isParameter: false,
+							key: "SalesOrder",
+							label: "Sales Order No."
+						},
+						{
+							annotationPath: "/SalesOrderManage/SoldToParty",
+							availability: "Default",
+							caseSensitive: true,
+							conditionPath: "SoldToParty",
+							group: "",
+							groupLabel: "",
+							isParameter: false,
+							key: "SoldToParty",
+							label: "Sold-To Party"
+						},
+						{
+							annotationPath: "/SalesOrderManage/OverallSDProcessStatus",
+							availability: "Default",
+							caseSensitive: true,
+							conditionPath: "OverallSDProcessStatus",
+							group: "",
+							groupLabel: "",
+							isParameter: false,
+							key: "OverallSDProcessStatus",
+							label: "Overall Status"
+						},
+						{
+							annotationPath: "/SalesOrderManage/_SalesGroup_SalesGroup",
+							availability: "Adaptation",
+							caseSensitive: true,
+							conditionPath: "_SalesGroup_SalesGroup",
+							group: "SalesOrderManage",
+							groupLabel: "Manage Sales Order",
+							key: "_SalesGroup_SalesGroup",
+							label: "_SalesGroup_SalesGroup"
+						}
+					];
+				});
+				jest.spyOn(PropertyFormatters, "hasValueHelp").mockImplementation(() => true);
+				jest.spyOn(DelegateUtil, "getCustomData").mockReturnValue("/SalesOrderManage/");
+				jest.spyOn(StateUtil, "applyExternalState").mockResolvedValue(true);
+			});
+
+			afterAll(() => {
+				jest.restoreAllMocks();
+			});
+
+			it("check if conditions are applied correctly", async () => {
+				const order = {
+					operator: "EQ",
+					validated: "Validated",
+					values: ["6437"]
+				};
+				const condition = {
+					SalesOrder: [
+						{
+							...order,
+							isEmpty: "null"
+						}
+					],
+					SoldToParty: [
+						{
+							operator: "Empty",
+							validated: "Validated",
+							values: ["69406910"]
+						}
+					],
+					OverallSDProcessStatus: [
+						{
+							operator: "EQ",
+							isEmpty: "null",
+							validated: "Validated",
+							values: ["A"]
+						}
+					]
+				};
+
+				const state = {
+					filter: {
+						_SalesGroup_SalesGroup: [],
+						SalesOrder: [order],
+						SoldToParty: [
+							{
+								operator: "EQ",
+								validated: "Validated",
+								values: [""]
+							}
+						]
+					},
+					items: [
+						{
+							name: "SalesOrder"
+						},
+						{
+							name: "SoldToParty"
+						}
+					]
+				};
+				const filterBar = mockFilterBar();
+				filterBar.mock.initialized.mockResolvedValue(true);
+				filterBar.mock.getModel.mockReturnValue(app.model);
+
+				const metaModel = app.model.mock.getMetaModel();
+				metaModel.mock.createBindingContext.mockReturnValue({ getObject: jest.fn() });
+
+				await viewState._fnApplyConditions(filterBar, condition);
+				expect(StateUtil.applyExternalState).toHaveBeenCalledWith(filterBar, state);
+			});
+		});
+	});
+});

package/packages/sap.fe.templates/test/sap/fe/templates/jest/ObjectPage/AnnotationHelper.spec.js

@@ -0,0 +1,99 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2021 SAP SE. All rights reserved
+ */
+sap.ui.define(["sap/fe/test/JestTemplatingHelper"], function (JestTemplatingHelper) {
+  "use strict";
+
+  var evaluateBindingWithModel = JestTemplatingHelper.evaluateBindingWithModel;
+
+  var checkDraftState = jest.fn();
+  var AnnotationHelper;
+  sap.ui.define(["sap/fe/templates/ObjectPage/AnnotationHelper"], function (annotationHelper) {
+    AnnotationHelper = annotationHelper;
+    AnnotationHelper.checkDraftState = checkDraftState;
+  });
+  describe("Draft toggle button: Switch to active", function () {
+    it("should not be statically invisible in non-draft mode", function () {
+      checkDraftState.mockReturnValue(false);
+      var bindingExpression = AnnotationHelper.getSwitchToActiveVisibility({});
+      expect(bindingExpression).toEqual(false);
+    });
+    it("should be visible for own drafts in edit mode", function () {
+      checkDraftState.mockReturnValue(true);
+      var bindingExpression = AnnotationHelper.getSwitchToActiveVisibility({});
+      var evaluationResult = evaluateBindingWithModel(bindingExpression, {
+        DraftAdministrativeData: {
+          DraftIsCreatedByMe: true
+        }
+      }, {
+        ui: {
+          editMode: "Editable",
+          createMode: false
+        }
+      });
+      expect(evaluationResult).toEqual("true");
+    });
+    it("should not be visible for own drafts in create mode", function () {
+      checkDraftState.mockReturnValue(true);
+      var bindingExpression = AnnotationHelper.getSwitchToActiveVisibility({});
+      var evaluationResult = evaluateBindingWithModel(bindingExpression, {
+        DraftAdministrativeData: {
+          DraftIsCreatedByMe: true
+        }
+      }, {
+        ui: {
+          editMode: "Editable",
+          createMode: true
+        }
+      });
+      expect(evaluationResult).toEqual("false");
+    });
+    it("should not be visible for own drafts in display mode", function () {
+      checkDraftState.mockReturnValue(true);
+      var bindingExpression = AnnotationHelper.getSwitchToActiveVisibility({});
+      var evaluationResult = evaluateBindingWithModel(bindingExpression, {
+        DraftAdministrativeData: {
+          DraftIsCreatedByMe: true
+        }
+      }, {
+        ui: {
+          editMode: "Display",
+          createMode: false
+        }
+      });
+      expect(evaluationResult).toEqual("false");
+    });
+    it("should not be visible for indefinite DraftIsCreatedByMe property in edit mode", function () {
+      checkDraftState.mockReturnValue(true);
+      var bindingExpression = AnnotationHelper.getSwitchToActiveVisibility({});
+      var evaluationResult = evaluateBindingWithModel(bindingExpression, {
+        DraftAdministrativeData: {
+          DraftIsCreatedByMe: null
+        }
+      }, {
+        ui: {
+          editMode: "Editable",
+          createMode: false
+        }
+      });
+      expect(evaluationResult).toEqual("false");
+    });
+    it("should not be visible for indefinite DraftIsCreatedByMe property in display mode", function () {
+      checkDraftState.mockReturnValue(true);
+      var bindingExpression = AnnotationHelper.getSwitchToActiveVisibility({});
+      var evaluationResult = evaluateBindingWithModel(bindingExpression, {
+        DraftAdministrativeData: {
+          DraftIsCreatedByMe: null
+        }
+      }, {
+        ui: {
+          editMode: "Display",
+          createMode: false
+        }
+      });
+      expect(evaluationResult).toEqual("false");
+    });
+  });
+}, false);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["AnnotationHelper.spec.ts"],"names":["checkDraftState","jest","fn","AnnotationHelper","sap","ui","define","annotationHelper","describe","it","mockReturnValue","bindingExpression","getSwitchToActiveVisibility","expect","toEqual","evaluationResult","evaluateBindingWithModel","DraftAdministrativeData","DraftIsCreatedByMe","editMode","createMode"],"mappings":"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","sourceRoot":".","sourcesContent":["import { AnnotationHelperType } from \"sap/fe/templates/ObjectPage\";\nimport { evaluateBindingWithModel } from \"sap/fe/test/JestTemplatingHelper\";\n\nconst checkDraftState = jest.fn();\nlet AnnotationHelper: AnnotationHelperType;\nsap.ui.define([\"sap/fe/templates/ObjectPage/AnnotationHelper\"], (annotationHelper: AnnotationHelperType) => {\n\tAnnotationHelper = annotationHelper;\n\tAnnotationHelper.checkDraftState = checkDraftState;\n});\n\ndescribe(\"Draft toggle button: Switch to active\", () => {\n\tit(\"should not be statically invisible in non-draft mode\", () => {\n\t\tcheckDraftState.mockReturnValue(false);\n\t\tconst bindingExpression = AnnotationHelper.getSwitchToActiveVisibility({});\n\t\texpect(bindingExpression).toEqual(false);\n\t});\n\n\tit(\"should be visible for own drafts in edit mode\", () => {\n\t\tcheckDraftState.mockReturnValue(true);\n\t\tconst bindingExpression = AnnotationHelper.getSwitchToActiveVisibility({});\n\n\t\tconst evaluationResult = evaluateBindingWithModel(\n\t\t\tbindingExpression,\n\t\t\t{ DraftAdministrativeData: { DraftIsCreatedByMe: true } },\n\t\t\t{ ui: { editMode: \"Editable\", createMode: false } }\n\t\t);\n\n\t\texpect(evaluationResult).toEqual(\"true\");\n\t});\n\n\tit(\"should not be visible for own drafts in create mode\", () => {\n\t\tcheckDraftState.mockReturnValue(true);\n\t\tconst bindingExpression = AnnotationHelper.getSwitchToActiveVisibility({});\n\n\t\tconst evaluationResult = evaluateBindingWithModel(\n\t\t\tbindingExpression,\n\t\t\t{ DraftAdministrativeData: { DraftIsCreatedByMe: true } },\n\t\t\t{ ui: { editMode: \"Editable\", createMode: true } }\n\t\t);\n\n\t\texpect(evaluationResult).toEqual(\"false\");\n\t});\n\n\tit(\"should not be visible for own drafts in display mode\", () => {\n\t\tcheckDraftState.mockReturnValue(true);\n\t\tconst bindingExpression = AnnotationHelper.getSwitchToActiveVisibility({});\n\n\t\tconst evaluationResult = evaluateBindingWithModel(\n\t\t\tbindingExpression,\n\t\t\t{ DraftAdministrativeData: { DraftIsCreatedByMe: true } },\n\t\t\t{ ui: { editMode: \"Display\", createMode: false } }\n\t\t);\n\n\t\texpect(evaluationResult).toEqual(\"false\");\n\t});\n\n\tit(\"should not be visible for indefinite DraftIsCreatedByMe property in edit mode\", () => {\n\t\tcheckDraftState.mockReturnValue(true);\n\t\tconst bindingExpression = AnnotationHelper.getSwitchToActiveVisibility({});\n\n\t\tconst evaluationResult = evaluateBindingWithModel(\n\t\t\tbindingExpression,\n\t\t\t{ DraftAdministrativeData: { DraftIsCreatedByMe: null } },\n\t\t\t{ ui: { editMode: \"Editable\", createMode: false } }\n\t\t);\n\n\t\texpect(evaluationResult).toEqual(\"false\");\n\t});\n\n\tit(\"should not be visible for indefinite DraftIsCreatedByMe property in display mode\", () => {\n\t\tcheckDraftState.mockReturnValue(true);\n\t\tconst bindingExpression = AnnotationHelper.getSwitchToActiveVisibility({});\n\n\t\tconst evaluationResult = evaluateBindingWithModel(\n\t\t\tbindingExpression,\n\t\t\t{ DraftAdministrativeData: { DraftIsCreatedByMe: null } },\n\t\t\t{ ui: { editMode: \"Display\", createMode: false } }\n\t\t);\n\n\t\texpect(evaluationResult).toEqual(\"false\");\n\t});\n});\n"]}

package/packages/sap.fe.templates/test/sap/fe/templates/jest/ObjectPage/AnnotationHelper.spec.ts

@@ -0,0 +1,82 @@
+import { AnnotationHelperType } from "sap/fe/templates/ObjectPage";
+import { evaluateBindingWithModel } from "sap/fe/test/JestTemplatingHelper";
+
+const checkDraftState = jest.fn();
+let AnnotationHelper: AnnotationHelperType;
+sap.ui.define(["sap/fe/templates/ObjectPage/AnnotationHelper"], (annotationHelper: AnnotationHelperType) => {
+	AnnotationHelper = annotationHelper;
+	AnnotationHelper.checkDraftState = checkDraftState;
+});
+
+describe("Draft toggle button: Switch to active", () => {
+	it("should not be statically invisible in non-draft mode", () => {
+		checkDraftState.mockReturnValue(false);
+		const bindingExpression = AnnotationHelper.getSwitchToActiveVisibility({});
+		expect(bindingExpression).toEqual(false);
+	});
+
+	it("should be visible for own drafts in edit mode", () => {
+		checkDraftState.mockReturnValue(true);
+		const bindingExpression = AnnotationHelper.getSwitchToActiveVisibility({});
+
+		const evaluationResult = evaluateBindingWithModel(
+			bindingExpression,
+			{ DraftAdministrativeData: { DraftIsCreatedByMe: true } },
+			{ ui: { editMode: "Editable", createMode: false } }
+		);
+
+		expect(evaluationResult).toEqual("true");
+	});
+
+	it("should not be visible for own drafts in create mode", () => {
+		checkDraftState.mockReturnValue(true);
+		const bindingExpression = AnnotationHelper.getSwitchToActiveVisibility({});
+
+		const evaluationResult = evaluateBindingWithModel(
+			bindingExpression,
+			{ DraftAdministrativeData: { DraftIsCreatedByMe: true } },
+			{ ui: { editMode: "Editable", createMode: true } }
+		);
+
+		expect(evaluationResult).toEqual("false");
+	});
+
+	it("should not be visible for own drafts in display mode", () => {
+		checkDraftState.mockReturnValue(true);
+		const bindingExpression = AnnotationHelper.getSwitchToActiveVisibility({});
+
+		const evaluationResult = evaluateBindingWithModel(
+			bindingExpression,
+			{ DraftAdministrativeData: { DraftIsCreatedByMe: true } },
+			{ ui: { editMode: "Display", createMode: false } }
+		);
+
+		expect(evaluationResult).toEqual("false");
+	});
+
+	it("should not be visible for indefinite DraftIsCreatedByMe property in edit mode", () => {
+		checkDraftState.mockReturnValue(true);
+		const bindingExpression = AnnotationHelper.getSwitchToActiveVisibility({});
+
+		const evaluationResult = evaluateBindingWithModel(
+			bindingExpression,
+			{ DraftAdministrativeData: { DraftIsCreatedByMe: null } },
+			{ ui: { editMode: "Editable", createMode: false } }
+		);
+
+		expect(evaluationResult).toEqual("false");
+	});
+
+	it("should not be visible for indefinite DraftIsCreatedByMe property in display mode", () => {
+		checkDraftState.mockReturnValue(true);
+		const bindingExpression = AnnotationHelper.getSwitchToActiveVisibility({});
+
+		const evaluationResult = evaluateBindingWithModel(
+			bindingExpression,
+			{ DraftAdministrativeData: { DraftIsCreatedByMe: null } },
+			{ ui: { editMode: "Display", createMode: false } }
+		);
+
+		expect(evaluationResult).toEqual("false");
+	});
+});

package/packages/sap.fe.templates/test/sap/fe/templates/jest/ObjectPage/view/fragments/Heading.spec.js

@@ -0,0 +1,50 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2021 SAP SE. All rights reserved
+ */
+sap.ui.define(["sap/fe/test/JestTemplatingHelper"], function (JestTemplatingHelper) {
+  "use strict";
+
+  var processFragment = JestTemplatingHelper.processFragment;
+
+  describe("Fragment: Heading", function () {
+    it("Heading without avatar", function () {
+      try {
+        return Promise.resolve(processFragment("sap.fe.templates.ObjectPage.view.fragments.Heading", {
+          header: {
+            title: {
+              expandedImageVisible: true
+            }
+          },
+          entityType: {}
+        })).then(function (xml) {
+          expect(xml).toMatchSnapshot();
+        });
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    });
+    it("Heading with avatar", function () {
+      try {
+        return Promise.resolve(processFragment("sap.fe.templates.ObjectPage.view.fragments.Heading", {
+          header: {
+            title: {
+              expandedImageVisible: true
+            },
+            avatar: {
+              src: "sap-icon://xxxx",
+              fallbackIcon: "sap-icon://person-placeholder",
+              displayShape: "Circle"
+            }
+          },
+          entityType: {}
+        })).then(function (xml) {
+          expect(xml).toMatchSnapshot();
+        });
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    });
+  });
+}, false);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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