@openui5/sap.ui.core 1.117.1 → 1.119.0

package/test/sap/ui/core/qunit/Theming.qunit.js

@@ -5,12 +5,14 @@ sap.ui.define([
 	"sap/base/Event",
 	"sap/ui/base/config/URLConfigurationProvider",
 	"sap/ui/core/Theming",
+	"sap/ui/core/theming/ThemeHelper",
 	"sap/ui/qunit/utils/waitForThemeApplied"
 ], function (
 	BaseConfig,
 	BaseEvent,
 	URLConfigurationProvider,
 	Theming,
+	ThemeHelper,
 	themeApplied
 ) {
 	"use strict";
@@ -51,29 +53,37 @@ sap.ui.define([
 		});
 	}
 
-	QUnit.module("Theming", {
-		beforeEach: function (assert) {
-			mConfigStubValues = {};
-			mEventCalls = {
-				aChange: [],
-				aApplied: []
-			};
-			oURLConfigurationProviderStub = sinon.stub(URLConfigurationProvider, "get");
-			oURLConfigurationProviderStub.callsFake(function(sKey) {
-					return mConfigStubValues.hasOwnProperty(sKey) ? mConfigStubValues[sKey] : oURLConfigurationProviderStub.wrappedMethod.call(this, sKey);
-			});
-			Theming.attachChange(checkChange);
-			Theming.attachApplied(checkApplied);
-			if (bThemeManagerNotActive) {
-				assert.strictEqual(mEventCalls.aApplied[0].theme, Theming.getTheme(), "In case there is no ThemeManager, the applied event should be called immediately.");
-				mEventCalls.aApplied.pop();
-			}
-		},
-		afterEach: function () {
-			Theming.detachChange(checkChange);
-			Theming.detachApplied(checkApplied);
-			oURLConfigurationProviderStub.restore();
+	function setupTestsBeforeEach(assert) {
+		mConfigStubValues = {};
+		oURLConfigurationProviderStub = sinon.stub(URLConfigurationProvider, "get");
+		oURLConfigurationProviderStub.callsFake(function(sKey) {
+				return mConfigStubValues.hasOwnProperty(sKey) ? mConfigStubValues[sKey] : oURLConfigurationProviderStub.wrappedMethod.call(this, sKey);
+		});
+		mEventCalls = {
+			aChange: [],
+			aApplied: []
+		};
+		Theming.attachChange(checkChange);
+		Theming.attachApplied(checkApplied);
+		if (bThemeManagerNotActive) {
+			assert.strictEqual(mEventCalls.aApplied[0].theme, Theming.getTheme(), "In case there is no ThemeManager, the applied event should be called immediately.");
+			mEventCalls.aApplied.pop();
 		}
+		mEventCalls = {
+			aChange: [],
+			aApplied: []
+		};
+	}
+
+	function setupTestsAfterEach() {
+		Theming.detachChange(checkChange);
+		Theming.detachApplied(checkApplied);
+		oURLConfigurationProviderStub.restore();
+	}
+
+	QUnit.module("Initial Configuration", {
+		beforeEach: setupTestsBeforeEach,
+		afterEach: setupTestsAfterEach
 	});
 
 	/**
@@ -83,27 +93,31 @@ sap.ui.define([
 	 * Before fixing this regression, an empty string lead to a "Maximum call stack size exceeded" error.
 	 */
 	QUnit.test("Initial Theme - empty string fallback", function(assert) {
-		assert.equal(Theming.getTheme(), "base", "Initial Theme after bootstrapping should be 'base'");
+		const sExpectedDefaultTheme = ThemeHelper.getDefaultThemeInfo().DEFAULT_THEME;
+		assert.equal(Theming.getTheme(), sExpectedDefaultTheme, `Initial Theme after bootstrapping should be ${sExpectedDefaultTheme}`);
 	});
 
 	QUnit.test("getTheme", function (assert) {
 		assert.expect(bThemeManagerNotActive ? 28 : 27);
 		BaseConfig._.invalidate();
+
+		const sExpectedDefaultTheme = ThemeHelper.getDefaultThemeInfo().DEFAULT_THEME;
+
 		mConfigStubValues = {
-			"sapTheme": "sap_test_theme_1",
-			"sapUiTheme": "sap_test_theme_2"
+			"sapTheme": "sap_horizon",
+			"sapUiTheme": "sap_fiori_3"
 		};
 		// sapTheme should be first
-		return fnAssert("sap_test_theme_1").then(function() {
+		return fnAssert("sap_horizon").then(function() {
 			BaseConfig._.invalidate();
 			mConfigStubValues["sapTheme"] = undefined;
 			// if there is no sapTheme sapUiTheme should be used
-			return fnAssert("sap_test_theme_2");
+			return fnAssert("sap_fiori_3");
 		}).then(function() {
 			BaseConfig._.invalidate();
 			mConfigStubValues["sapUiTheme"] = undefined;
-			// use default value 'base' in case there is no theming parameter at all
-			return fnAssert("base");
+			// internally we determine a valid default theme in case there is no theme given at all
+			return fnAssert(sExpectedDefaultTheme);
 		}).then(function() {
 			BaseConfig._.invalidate();
 			mConfigStubValues["sapTheme"] = "sap_test_theme_3@/sap/test/themeroot";
@@ -132,8 +146,9 @@ sap.ui.define([
 		}).then(function() {
 			// sap_corbu theme should be normalized to sap_fiori_3 theme
 			BaseConfig._.invalidate();
+			// sap_corbu theme should be normalized to the latest default theme
 			mConfigStubValues["sapTheme"] = "sap_corbu";
-			return fnAssert("sap_fiori_3");
+			return fnAssert(sExpectedDefaultTheme);
 		}).then(function() {
 			// sap_corbu theme with specific themeroots should not be normalized and themeroots for sap_corbu should trigger a change event
 			BaseConfig._.invalidate();
@@ -148,12 +163,23 @@ sap.ui.define([
 		});
 	});
 
+	QUnit.module("Theming runtime behavior", {
+		beforeEach: async function (assert) {
+			// make sure we have a fixed theme to begin with
+			Theming.setTheme("sap_horizon");
+			await themeApplied();
+
+			setupTestsBeforeEach(assert);
+		},
+		afterEach: setupTestsAfterEach
+	});
+
 	QUnit.test("setTheme", function(assert) {
 		Theming.setTheme("sap_hcb");
 
 		return fnAssert("sap_hcb", [{
 			theme: {
-				"old": "base",
+				"old": ThemeHelper.getDefaultThemeInfo().DEFAULT_THEME,
 				"new": "sap_hcb"
 			}
 		}], [{
@@ -175,22 +201,22 @@ sap.ui.define([
 		var sOldTheme = Theming.getTheme();
 		var sExpectedOldThemeRoot;
 		var sExpectedNewThemeRoot;
-		Theming.setTheme("sap_test_theme_4");
+		Theming.setTheme("my_private_theme");
 
-		return fnAssert("sap_test_theme_4", [{
+		return fnAssert("my_private_theme", [{
 			theme: {
 				"old": sOldTheme,
-				"new": "sap_test_theme_4"
+				"new": "my_private_theme"
 			}
 		}], [{
-			theme: "sap_test_theme_4"
+			theme: "my_private_theme"
 		}]).then(function() {
 			assert.strictEqual(Theming.getThemeRoot(), sExpectedNewThemeRoot, "ThemeRoot without parameter should return the expected themeRoot '" + sExpectedNewThemeRoot + "'");
-			assert.strictEqual(Theming.getThemeRoot("sap_test_theme_4"), sExpectedNewThemeRoot, "ThemeRoot for current theme should return the expected themeRoot '" + sExpectedNewThemeRoot + "'");
+			assert.strictEqual(Theming.getThemeRoot("my_private_theme"), sExpectedNewThemeRoot, "ThemeRoot for current theme should return the expected themeRoot '" + sExpectedNewThemeRoot + "'");
 
 			sExpectedNewThemeRoot = "sap/another/themeroot";
-			Theming.setThemeRoot("sap_test_theme_4", "sap/another/themeroot", true);
-			return fnAssert("sap_test_theme_4", [{
+			Theming.setThemeRoot("my_private_theme", "sap/another/themeroot", true);
+			return fnAssert("my_private_theme", [{
 				themeRoots: {
 					"new": sExpectedNewThemeRoot,
 					"old": sExpectedOldThemeRoot,
@@ -199,12 +225,12 @@ sap.ui.define([
 			}]);
 		}).then(function() {
 			assert.strictEqual(Theming.getThemeRoot(), sExpectedNewThemeRoot, "ThemeRoot without parameter should return the expected themeRoot '" + sExpectedNewThemeRoot + "'");
-			assert.strictEqual(Theming.getThemeRoot("sap_test_theme_4"), sExpectedNewThemeRoot, "ThemeRoot for current theme should return the expected themeRoot '" + sExpectedNewThemeRoot + "'");
+			assert.strictEqual(Theming.getThemeRoot("my_private_theme"), sExpectedNewThemeRoot, "ThemeRoot for current theme should return the expected themeRoot '" + sExpectedNewThemeRoot + "'");
 
 			sExpectedOldThemeRoot = sExpectedNewThemeRoot;
 			sExpectedNewThemeRoot = "sap/themeroot/for/libs";
-			Theming.setThemeRoot("sap_test_theme_4", "sap/themeroot/for/libs", ["sap_test_lib1", "sap_test_lib2"], true);
-			return fnAssert("sap_test_theme_4", [{
+			Theming.setThemeRoot("my_private_theme", "sap/themeroot/for/libs", ["sap_test_lib1", "sap_test_lib2"], true);
+			return fnAssert("my_private_theme", [{
 				themeRoots: {
 					"old": {
 						"": sExpectedOldThemeRoot
@@ -221,27 +247,39 @@ sap.ui.define([
 	});
 
 	QUnit.test("setThemeRoot - Initial 'string' value must be overridable by API", function(assert) {
-		var sThemeName = "sap_initialThemeRoot";
+		var sThemeName = "theme_with_initial_themeRoot";
 		var sInitialThemeRoot = "/somewhere/outside";
 
 		assert.strictEqual(Theming.getThemeRoot(sThemeName), sInitialThemeRoot, "ThemeRoot for '" + sThemeName + "' should return the expected themeRoot '" + sInitialThemeRoot + "'");
 
 		// Regression test: must not fail when initial theme-root is given only as a string, e.g.
 		//                  themeRoots: {
-		//                      "sap_initialThemeRoot": "/somewhere/outside"
+		//                      "theme_with_initial_themeRoot": "/somewhere/outside"
 		//                  }
 		Theming.setThemeRoot(sThemeName, "https://back/inside");
 	});
 
-	QUnit.test("isApplied", function(assert) {
-		assert.ok(Theming.isApplied(), "Theming should be applied.");
+	QUnit.test("isApplied", async function(assert) {
+		function isApplied() {
+			var bApplied = false;
+			function fnCheckApplied() {
+				bApplied = true;
+			}
+			// if theme is applied fnCheckApplied is called sync
+			Theming.attachApplied(fnCheckApplied);
+			Theming.detachApplied(fnCheckApplied);
+			return bApplied;
+		}
 
-		Theming.setTheme("sap_test_theme_5");
-		assert.strictEqual(Theming.isApplied(), bThemeManagerNotActive, "'true' if ThemeManager is active; else 'false'");
+		assert.ok(isApplied(), "Theming should be applied.");
 
-		return themeApplied().then(function() {
-			assert.ok(Theming.isApplied(), "Theming should be applied.");
-		});
+		// check if isApplied flag is reset after setting a new theme
+		Theming.setTheme("my_test_theme_for_applied");
+		assert.strictEqual(isApplied(), bThemeManagerNotActive, "'true' if ThemeManager is active; else 'false'");
+
+		await themeApplied();
+
+		assert.ok(isApplied(), "Theming should be applied.");
 	});
 
 });

package/test/sap/ui/core/qunit/Theming_default_and_fallback.qunit.js

@@ -0,0 +1,130 @@
+/* global QUnit, sinon, globalThis */
+
+sap.ui.define([
+	"sap/base/Event",
+	"sap/ui/base/config/URLConfigurationProvider",
+	"sap/ui/core/Theming",
+	"sap/ui/core/theming/ThemeHelper",
+	"sap/ui/qunit/utils/waitForThemeApplied"
+], function (
+	BaseEvent,
+	URLConfigurationProvider,
+	Theming,
+	ThemeHelper,
+	themeApplied
+) {
+	"use strict";
+
+	var oURLConfigurationProviderStub,
+		mConfigStubValues,
+		mEventCalls,
+		bThemeManagerNotActive = !!globalThis["sap-ui-test-config"].themeManagerNotActive;
+
+	function checkChange(oEvent) {
+		mEventCalls.aChange.push(BaseEvent.getParameters(oEvent));
+	}
+
+	function checkApplied(oEvent) {
+		mEventCalls.aApplied.push(BaseEvent.getParameters(oEvent));
+	}
+
+	function fnAssert(sTheme, aChangeEvents, aAppliedEvents) {
+		// Always wait for possible themeApplied
+		aChangeEvents = aChangeEvents || [];
+		aAppliedEvents = aAppliedEvents || [];
+		QUnit.assert.strictEqual(Theming.getTheme(), sTheme, "Theming.getTheme() should return theme '" + sTheme + "' with provider setup " + JSON.stringify(mConfigStubValues) + ".");
+		return themeApplied().then(function() {
+			QUnit.assert.strictEqual(mEventCalls.aChange.length, aChangeEvents.length, "There should " + aChangeEvents.length + " 'change' event(s).");
+			QUnit.assert.strictEqual(mEventCalls.aApplied.length, aAppliedEvents.length, "There should " + aAppliedEvents.length + " 'applied' event(s).");
+
+			for (var i = aChangeEvents.length - 1; i >= 0; i--) {
+				QUnit.assert.deepEqual(mEventCalls.aChange[i], aChangeEvents[i], "Expected parameters in 'change' event.");
+				mEventCalls.aChange.pop();
+				aChangeEvents.pop();
+			}
+
+			for (var j = aAppliedEvents.length - 1; j >= 0; j--) {
+				QUnit.assert.deepEqual(mEventCalls.aApplied[j], aAppliedEvents[j], "Expected parameters in 'applied' event.");
+				mEventCalls.aApplied.pop();
+				aAppliedEvents.pop();
+			}
+		});
+	}
+
+	QUnit.module("Theming", {
+		beforeEach: function (assert) {
+			mConfigStubValues = {};
+			mEventCalls = {
+				aChange: [],
+				aApplied: []
+			};
+			oURLConfigurationProviderStub = sinon.stub(URLConfigurationProvider, "get");
+			oURLConfigurationProviderStub.callsFake(function(sKey) {
+					return mConfigStubValues.hasOwnProperty(sKey) ? mConfigStubValues[sKey] : oURLConfigurationProviderStub.wrappedMethod.call(this, sKey);
+			});
+			Theming.attachChange(checkChange);
+			Theming.attachApplied(checkApplied);
+			if (bThemeManagerNotActive) {
+				assert.strictEqual(mEventCalls.aApplied[0].theme, Theming.getTheme(), "In case there is no ThemeManager, the applied event should be called immediately.");
+				mEventCalls.aApplied.pop();
+			}
+			mEventCalls = {
+				aChange: [],
+				aApplied: []
+			};
+		},
+		afterEach: function () {
+			Theming.detachChange(checkChange);
+			Theming.detachApplied(checkApplied);
+			oURLConfigurationProviderStub.restore();
+		}
+	});
+
+	QUnit.test("setTheme - fallback to default theme", async function(assert) {
+		const sCurrentTheme = Theming.getTheme();
+		const sCalculatedDefaultTheme = ThemeHelper.getDefaultThemeInfo().DEFAULT_THEME;
+
+		// 0. Check if initially set theme via bootstrap is correctly changed to a valid default
+		assert.equal(sCurrentTheme, sCalculatedDefaultTheme, "Initial theme is correctly set when bootstrap provides outdated theme name");
+
+		// 1. fresh start with a consistent valid theme
+		//    no fallback should be applied
+		Theming.setTheme("sap_fiori_3_hcw");
+
+		await fnAssert("sap_fiori_3_hcw",
+			// change event for "theme"
+			[{ theme: { "old": sCurrentTheme, "new": "sap_fiori_3_hcw" } }],
+			// applied event with new theme name
+			[{ theme: "sap_fiori_3_hcw" }]);
+
+		// 2. set a theme that is no longer supported
+		//    fallback to default (Aug. 2023: "sap_horizon") should be applied
+		Theming.setTheme("sap_goldreflection");
+
+		await fnAssert(sCalculatedDefaultTheme,
+			// change event for "theme"
+			[{ theme: { "old": "sap_fiori_3_hcw", "new": sCalculatedDefaultTheme } }],
+			// applied event with new theme name
+			[{ theme: sCalculatedDefaultTheme }]);
+
+		// 3. another invalid theme is set
+		//    no further events should be fired after setting another invalid theme
+		Theming.setTheme("sap_platinum");
+
+		await fnAssert(sCalculatedDefaultTheme,
+			// no change event for "theme"
+			[],
+			// no further applied event, since the theme is not changed
+			[]);
+
+		// 4. setting a valid theme again should work
+		Theming.setTheme("sap_belize");
+
+		await fnAssert("sap_belize",
+			// change event for "theme"
+			[{ theme: { "old": sCalculatedDefaultTheme, "new": "sap_belize" } }],
+			// applied event with new theme name
+			[{ theme: "sap_belize" }]);
+	});
+
+});

package/test/sap/ui/core/qunit/TooltipBase.qunit.js

@@ -1,12 +1,14 @@
 /*global QUnit, sinon */
 sap.ui.define([
+	"sap/ui/core/Element",
 	"sap/ui/core/TooltipBase",
 	"sap/ui/qunit/QUnitUtils",
 	"sap/ui/layout/HorizontalLayout",
 	"sap/m/Button",
 	"sap/ui/qunit/utils/createAndAppendDiv",
+	"sap/ui/qunit/utils/nextUIUpdate",
 	"sap/ui/events/KeyCodes"
-], function (TooltipBase, QUnitUtils, HorizontalLayout, Button, createAndAppendDiv, KeyCodes) {
+], function (Element, TooltipBase, QUnitUtils, HorizontalLayout, Button, createAndAppendDiv, nextUIUpdate, KeyCodes) {
 	"use strict";
 
 	createAndAppendDiv("target");
@@ -213,7 +215,7 @@ sap.ui.define([
 			this.oSpyOpenPopup1 = sinon.spy(this.oTooltip1, "openPopup");
 			this.oSpyClosePopup1 = sinon.spy(this.oTooltip1, "closePopup");
 
-			sap.ui.getCore().applyChanges();
+			return nextUIUpdate();
 		},
 
 		afterEach: function() {
@@ -354,7 +356,7 @@ sap.ui.define([
 			this.oSpyOpenPopupLayout = sinon.spy(this.oTooltipLayout, "openPopup");
 			this.oSpyClosePopupLayout = sinon.spy(this.oTooltipLayout, "closePopup");
 
-			sap.ui.getCore().applyChanges();
+			return nextUIUpdate();
 		},
 
 		afterEach: function() {
@@ -507,7 +509,7 @@ sap.ui.define([
 
 		// needed to wait for rendering the icons
 		setTimeout(function() {
-			var oIcon = sap.ui.getCore().byId(this.oButton2.getId() + "-img");
+			var oIcon = Element.getElementById(this.oButton2.getId() + "-img");
 			var oSpyIconMoveOver = sinon.spy(oIcon, "onmouseover");
 
 			QUnitUtils.triggerMouseEvent(this.oButton2.$(), "mouseover");