@openui5/sap.ui.core 1.125.0 → 1.126.1

package/test/sap/ui/core/qunit/odata/v4/Context.qunit.js

@@ -4592,104 +4592,83 @@ sap.ui.define([
 	//*********************************************************************************************
 [false, true].forEach(function (bIsHeaderContext) {
 	[false, true].forEach(function (bHasChangeListeners) {
+		[false, true].forEach(function (bRowsChanged) {
+			[false, true].forEach(function (bSelectionChanged) {
 		if (!bIsHeaderContext && bHasChangeListeners) {
 			return; // unrealistic
 		}
+		if (bRowsChanged && !bSelectionChanged) {
+			return;
+		}
 		const sTitle = `setSelected: is header context=${bIsHeaderContext},
-			with change listeners=${bHasChangeListeners}`;
+			with change listeners=${bHasChangeListeners} and rows' selection state
+			has changed=${bRowsChanged}`;
 
 	QUnit.test(sTitle, function () {
-		const oBinding = {getHeaderContext : mustBeMocked, _getAllExistingContexts : mustBeMocked};
+		const oBinding = {
+			fireSelectionChanged : mustBeMocked,
+			getHeaderContext : mustBeMocked,
+			_getAllExistingContexts : mustBeMocked
+		};
 		// Note: oBinding is optional, it might already be missing in certain cases!
 		const oContext = Context.create({/*oModel*/}, oBinding, "/some/path", 42);
 
 		if (bHasChangeListeners) {
 			oContext.mChangeListeners = "~mChangeListeners~";
 		}
-		this.mock(oContext).expects("isDeleted").withExactArgs().returns(false);
 		this.mock(oBinding).expects("getHeaderContext").returns(bIsHeaderContext ? oContext : null);
+		this.stub(oContext, "toString"); // called by SinonJS, would call #isDeleted :-(
+		this.mock(oContext).expects("isDeleted").withExactArgs().returns(false);
 		if (bIsHeaderContext) {
 			const aRowContexts = [
-				{setSelected : mustBeMocked},
-				{setSelected : mustBeMocked}
+				{doSetSelected : mustBeMocked},
+				{doSetSelected : mustBeMocked}
 			];
 			this.mock(oBinding).expects("_getAllExistingContexts").withExactArgs()
 				.returns(aRowContexts);
 			aRowContexts.forEach((oRowContext) => {
-				this.mock(oRowContext).expects("setSelected").withExactArgs("~selected~");
+				this.mock(oRowContext).expects("doSetSelected")
+					.withExactArgs("~selected~")
+					.returns(bRowsChanged);
 			});
 		}
-		this.mock(_Helper).expects("fireChange").exactly(bHasChangeListeners ? 1 : 0)
+		this.mock(oContext).expects("doSetSelected")
+			.withExactArgs("~selected~")
+			.returns(bSelectionChanged);
+		this.mock(_Helper).expects("fireChange")
+			.exactly((bSelectionChanged && bHasChangeListeners) ? 1 : 0)
 			.withExactArgs("~mChangeListeners~", "", "~selected~");
-		this.mock(oContext).expects("withCache")
-			.withExactArgs(sinon.match.func, "")
-			.callsFake((fnProcessor) => {
-				const oCache = {setProperty : mustBeMocked};
-				this.mock(oCache).expects("setProperty")
-					.withExactArgs("@$ui5.context.isSelected", "~selected~", "~sPath~");
-
-				return fnProcessor(oCache, "~sPath~");
-			});
-		this.mock(oContext).expects("doSetSelected").withExactArgs("~selected~");
+		this.mock(oContext.oBinding).expects("fireSelectionChanged")
+			.exactly((bSelectionChanged || bRowsChanged) ? 1 : 0)
+			.withExactArgs(sinon.match.same(oContext));
 
 		// code under test
 		oContext.setSelected("~selected~");
 	});
+			});
+		});
 	});
 });
 
 	//*********************************************************************************************
 	QUnit.test("setSelected: binding destroyed", function () {
 		const oBinding = {
+			fireSelectionChanged : mustBeMocked,
 			getHeaderContext : mustBeMocked
 		};
 		const oContext = Context.create({/*oModel*/}, oBinding, "/some/path", 42);
 
+		this.stub(oContext, "toString"); // called by SinonJS, would call #isDeleted :-(
 		this.mock(oContext).expects("isDeleted").withExactArgs().returns(false);
 		this.mock(oBinding).expects("getHeaderContext").returns(undefined);
-		this.mock(oContext).expects("withCache")
-			.withExactArgs(sinon.match.func, "")
-			.callsFake((fnProcessor) => {
-				oContext.oBinding = undefined;
-
-				return fnProcessor({}, "~sPath~");
-			});
-		this.mock(oContext).expects("doSetSelected").withExactArgs(true);
+		this.mock(oContext).expects("doSetSelected").withExactArgs(true).returns(true);
+		this.mock(oContext.oBinding).expects("fireSelectionChanged")
+			.withExactArgs(sinon.match.same(oContext));
 
 		// code under test - binding destroyed
 		oContext.setSelected(true);
 	});
 
-	//*********************************************************************************************
-	QUnit.test("setSelected: flag already set", function () {
-		const oBinding = {
-			getHeaderContext : mustBeMocked,
-			onKeepAliveChanged : mustBeMocked
-		};
-		const oContext = Context.create({/*oModel*/}, oBinding, "/some/path", 42);
-
-		oContext.mChangeListeners = "~mChangeListeners~";
-		this.mock(oContext).expects("isDeleted").twice().withExactArgs().returns(false);
-		this.mock(oBinding).expects("getHeaderContext").twice().returns(undefined);
-		this.mock(_Helper).expects("fireChange").withExactArgs("~mChangeListeners~", "", true);
-		this.mock(oContext).expects("withCache")
-			.withExactArgs(sinon.match.func, "")
-			.callsFake((fnProcessor) => {
-				const oCache = {setProperty : mustBeMocked};
-				this.mock(oCache).expects("setProperty")
-					.withExactArgs("@$ui5.context.isSelected", true, "~sPath~");
-
-				return fnProcessor(oCache, "~sPath~");
-			});
-		this.mock(oBinding).expects("onKeepAliveChanged").twice().withExactArgs(oContext);
-
-		// code under test
-		oContext.setSelected(true);
-
-		// code under test
-		oContext.setSelected(true);
-	});
-
 	//*********************************************************************************************
 	QUnit.test("setSelected: error handling", function (assert) {
 		const oBinding = {
@@ -4714,34 +4693,80 @@ sap.ui.define([
 	});
 
 	//*********************************************************************************************
-	QUnit.test("doSetSelected", function (assert) {
+[true, false].forEach(function (bDoNotUpdateAnnotation) {
+		const sTitle = "doSetSelected, binding is missing, update Annotation: "
+			+ !bDoNotUpdateAnnotation;
+
+	QUnit.test(sTitle, function (assert) {
 		// Note: oBinding is optional, it might already be missing in certain cases!
-		let oContext = Context.create({/*oModel*/}, /*oBinding*/undefined, "/some/path", 42);
+		const oContext = Context.create({/*oModel*/}, /*oBinding*/undefined, "/some/path", 42);
 
 		// code under test
 		assert.strictEqual(oContext.isSelected(), false);
 
+		const oContextMock = this.mock(oContext);
+		oContextMock.expects("withCache").exactly(bDoNotUpdateAnnotation ? 0 : 1)
+			.withExactArgs(sinon.match.func, "")
+			.callsFake((fnProcessor) => {
+				const oCache = {setProperty : mustBeMocked};
+				this.mock(oCache).expects("setProperty").never();
+
+				return fnProcessor(oCache, "/some/path");
+			});
+
 		// code under test
-		oContext.doSetSelected(true);
+		assert.strictEqual(oContext.doSetSelected(true, bDoNotUpdateAnnotation), true);
 
 		assert.strictEqual(oContext.isSelected(), true);
 
 		// code under test
 		assert.strictEqual(oContext.toString(), "/some/path[42;selected]");
 
+		oContextMock.expects("withCache").never();
+
 		// code under test
-		oContext.doSetSelected(false);
+		assert.strictEqual(oContext.doSetSelected(true, bDoNotUpdateAnnotation), false);
+
+		oContextMock.expects("withCache").exactly(bDoNotUpdateAnnotation ? 0 : 1)
+			.withExactArgs(sinon.match.func, "")
+			.callsFake((fnProcessor) => {
+				const oCache = {setProperty : mustBeMocked};
+				this.mock(oCache).expects("setProperty").never();
+
+				return fnProcessor(oCache, "/some/path");
+			});
+
+		// code under test
+		assert.strictEqual(oContext.doSetSelected(false, bDoNotUpdateAnnotation), true);
 
 		assert.strictEqual(oContext.isSelected(), false);
 
 		// code under test
 		assert.strictEqual(oContext.toString(), "/some/path[42]");
+	});
+});
+
+	//*********************************************************************************************
+[true, false].forEach(function (bDoNotUpdateAnnotation) {
+	const sTitle = "doSetSelected, context has binding, update Annotation: "
+		+ !bDoNotUpdateAnnotation;
 
-		oContext = Context.create({/*oModel*/}, {
+	QUnit.test(sTitle, function (assert) {
+		const oContext = Context.create({/*oModel*/}, {
 			getHeaderContext : true,
 			onKeepAliveChanged : function () {}
 		}, "/some/path", 42);
 
+		this.mock(oContext).expects("withCache").exactly(bDoNotUpdateAnnotation ? 0 : 1)
+			.withExactArgs(sinon.match.func, "")
+			.callsFake((fnProcessor) => {
+				const oCache = {setProperty : mustBeMocked};
+				this.mock(oCache).expects("setProperty")
+					.withExactArgs("@$ui5.context.isSelected", "~selected~", "/some/path");
+
+				return fnProcessor(oCache, "/some/path");
+			});
+
 		this.mock(oContext.oBinding).expects("onKeepAliveChanged")
 			.withExactArgs(sinon.match.same(oContext))
 			.callsFake(function () {
@@ -4749,8 +4774,9 @@ sap.ui.define([
 			});
 
 		// code under test
-		oContext.doSetSelected("~selected~");
+		assert.strictEqual(oContext.doSetSelected("~selected~", bDoNotUpdateAnnotation), true);
 	});
+});
 
 	//*********************************************************************************************
 	QUnit.test("isEffectivelyKeptAlive: explicitly", function (assert) {
@@ -4965,58 +4991,35 @@ sap.ui.define([
 	});
 
 	//*********************************************************************************************
-[-2, +2, -3, +3, 0].forEach((iOffset) => {
-	QUnit.test(`requestSibling: unsupported offset ${iOffset}`, function (assert) {
-		const oContext = Context.create({/*oModel*/}, {/*oBinding*/}, "/EMPLOYEES('42')", 42);
-
-		assert.throws(function () {
-			// code under test
-			oContext.requestSibling(iOffset);
-		}, new Error("Unsupported offset: " + iOffset));
-	});
-});
-
-	//*********************************************************************************************
-	QUnit.test("requestSibling: deleted/transient", function (assert) {
-		const oContext = Context.create({/*oModel*/}, {/*oBinding*/}, "/EMPLOYEES('42')", 42);
-		// also called by SinonJS, would call #isDeleted etc. :-(
-		oContext.toString = function () { return "~toString~"; };
-		const oContextMock = this.mock(oContext);
-		oContextMock.expects("isDeleted").withExactArgs().returns(true);
-		oContextMock.expects("isTransient").never();
-
-		assert.throws(function () {
-			// code under test
-			oContext.requestSibling();
-		}, new Error("Unsupported context: ~toString~"));
-
-		oContextMock.expects("isDeleted").withExactArgs().returns(false);
-		oContextMock.expects("isTransient").withExactArgs().returns(true);
+	QUnit.test("getSibling", function (assert) {
+		const oBinding = {
+			fetchOrGetSibling : mustBeMocked
+		};
+		const oContext = Context.create({/*oModel*/}, oBinding, "/EMPLOYEES('42')", 42);
+		this.mock(oBinding).expects("fetchOrGetSibling")
+			.withExactArgs(sinon.match.same(oContext), "~offset~")
+			.returns("~result~");
 
-		assert.throws(function () {
-			// code under test
-			oContext.requestSibling();
-		}, new Error("Unsupported context: ~toString~"));
+		// code under test
+		assert.strictEqual(oContext.getSibling("~offset~"), "~result~");
 	});
 
 	//*********************************************************************************************
-[{in : undefined, out : +1}, {in : +1, out : +1}, {in : -1, out : -1}].forEach((oFixture, i) => {
-	QUnit.test("requestSibling: #" + i, function (assert) {
+	QUnit.test("requestSibling", async function (assert) {
 		const oBinding = {
-			requestSibling : mustBeMocked
+			fetchOrGetSibling : mustBeMocked
 		};
 		const oContext = Context.create({/*oModel*/}, oBinding, "/EMPLOYEES('42')", 42);
-		// also called by SinonJS, would call #isDeleted etc. :-(
-		oContext.toString = function () { return "n/a"; };
-		this.mock(oContext).expects("isDeleted").withExactArgs().returns(false);
-		this.mock(oContext).expects("isTransient").withExactArgs().returns(false);
-		this.mock(oBinding).expects("requestSibling")
-			.withExactArgs(sinon.match.same(oContext), oFixture.out).returns("~result~");
+		this.mock(oBinding).expects("fetchOrGetSibling")
+			.withExactArgs(sinon.match.same(oContext), "~offset~", true)
+			.returns("~result~");
 
 		// code under test
-		assert.strictEqual(oContext.requestSibling(oFixture.in), "~result~");
+		const oPromise = oContext.requestSibling("~offset~");
+
+		assert.ok(oPromise instanceof Promise);
+		assert.strictEqual(await oPromise, "~result~");
 	});
-});
 
 	//*********************************************************************************************
 [0, 1].forEach(function (iFailureIndex) {

package/test/sap/ui/core/qunit/odata/v4/ODataBinding.qunit.js

@@ -3100,7 +3100,7 @@ sap.ui.define([
 	});
 
 	//*********************************************************************************************
-	QUnit.test("assertSameCache", function (assert) {
+	QUnit.test("checkSameCache", function (assert) {
 		var oBinding = new ODataBinding({
 				oCache : {}
 			}),
@@ -3108,10 +3108,10 @@ sap.ui.define([
 				toString : function () { return "~"; }
 			};
 
-		oBinding.assertSameCache(oBinding.oCache);
+		oBinding.checkSameCache(oBinding.oCache);
 
 		try {
-			oBinding.assertSameCache(oCache);
+			oBinding.checkSameCache(oCache);
 			assert.ok(false);
 		} catch (oError) {
 			assert.strictEqual(oError.message,

package/test/sap/ui/core/qunit/odata/v4/ODataContextBinding.qunit.js

@@ -862,7 +862,7 @@ sap.ui.define([
 			.withExactArgs(sinon.match.same(oGroupLock), "foo", sinon.match.func, undefined)
 			.callsArg(2)
 			.returns(SyncPromise.resolve(Promise.resolve()).then(function () {
-				that.mock(oBinding).expects("assertSameCache")
+				that.mock(oBinding).expects("checkSameCache")
 					.withExactArgs(sinon.match.same(oCache))
 					.throws(oError);
 				return {};
@@ -1102,7 +1102,7 @@ sap.ui.define([
 		this.mock(oCache).expects("fetchValue")
 			.withExactArgs(sinon.match.same(_GroupLock.$cached), "bar", sinon.match.func, null)
 			.returns(SyncPromise.resolve(42));
-		this.mock(oBinding).expects("assertSameCache").withExactArgs(oCache);
+		this.mock(oBinding).expects("checkSameCache").withExactArgs(oCache);
 
 		// code under test
 		return oBinding.fetchValue("/absolute/bar", null, true).then(function (vResult) {
@@ -1141,7 +1141,7 @@ sap.ui.define([
 		this.mock(oCache).expects("fetchValue")
 			.withExactArgs(sinon.match.same(oGroupLock), "bar", sinon.match.func, undefined)
 			.returns(SyncPromise.resolve(42));
-		this.mock(oBinding).expects("assertSameCache").withExactArgs(oCache);
+		this.mock(oBinding).expects("checkSameCache").withExactArgs(oCache);
 
 		// code under test
 		return oBinding.fetchValue("/absolute/bar").then(function (vResult) {
@@ -1678,8 +1678,8 @@ sap.ui.define([
 					// code under test: invoke creates a new cache with the new path
 					return oBinding.setParameter("foo", "bar")
 						._invoke(oGroupLock1, "~mParameters~", "~bIgnoreETag~")
-						.then(function (oReturnValueContext) {
-							assert.strictEqual(oReturnValueContext, undefined);
+						.then(function (oReturnValueContext0) {
+							assert.strictEqual(oReturnValueContext0, undefined);
 							if (oExpectation) {
 								assert.strictEqual(oExpectation.args[0][4](), oEntity);
 							}
@@ -2018,8 +2018,8 @@ sap.ui.define([
 		this.mock(this.oModel).expects("reportError")
 			.withExactArgs("Failed to invoke /TEAMS('42')/name.space.Operation(...)",
 				sClassName, sinon.match.same(oError))
-			.callsFake(function (_sLogMessage, _sReportingClassName, oError) {
-				assert.strictEqual(oError.resourcePath, "~"); // unchanged
+			.callsFake(function (_sLogMessage, _sReportingClassName, oError0) {
+				assert.strictEqual(oError0.resourcePath, "~"); // unchanged
 			});
 
 		// code under test
@@ -2071,8 +2071,8 @@ sap.ui.define([
 		this.mock(this.oModel).expects("reportError")
 			.withExactArgs("Failed to invoke /ActionImport(...)",
 				sClassName, sinon.match.same(oError))
-			.callsFake(function (_sLogMessage, _sReportingClassName, oError) {
-				assert.strictEqual(oError.resourcePath, "~"); // unchanged
+			.callsFake(function (_sLogMessage, _sReportingClassName, oError0) {
+				assert.strictEqual(oError0.resourcePath, "~"); // unchanged
 			});
 
 		// code under test
@@ -3090,8 +3090,8 @@ sap.ui.define([
 			.withExactArgs(sinon.match.same(oError), sinon.match.same(oOperationMetadata), "~Path~",
 				bRelative ? "~contextPath~" : undefined);
 		this.mock(_Helper).expects("extractMessages")
-			.withExactArgs(sinon.match(function (oError) {
-				return oError.error.$ignoreTopLevel === true;
+			.withExactArgs(sinon.match(function (oError0) {
+				return oError0.error.$ignoreTopLevel === true;
 			}))
 			.returns(aRawMessages);
 
@@ -3454,13 +3454,13 @@ sap.ui.define([
 
 				that.mock(oBinding).expects("createRefreshPromise").never();
 				oBinding.attachChange(function (oEvent) {
-					var oElementContext = oBinding.getBoundContext();
+					var oElementContext0 = oBinding.getBoundContext();
 
 					assert.strictEqual(oEvent.getParameter("reason"), ChangeReason.Refresh);
-					assert.strictEqual(oElementContext.getBinding(), oBinding);
-					assert.strictEqual(oElementContext.getModelIndex(), undefined);
-					assert.strictEqual(oElementContext.getModel(), this.oModel);
-					assert.strictEqual(oElementContext.getPath(), "/EMPLOYEES('42')");
+					assert.strictEqual(oElementContext0.getBinding(), oBinding);
+					assert.strictEqual(oElementContext0.getModelIndex(), undefined);
+					assert.strictEqual(oElementContext0.getModel(), this.oModel);
+					assert.strictEqual(oElementContext0.getPath(), "/EMPLOYEES('42')");
 				});
 
 				// code under test
@@ -4790,11 +4790,11 @@ sap.ui.define([
 					that.mock(oBinding).expects("visitSideEffects")
 						.withExactArgs(sGroupId, sinon.match.same(aPaths),
 							sinon.match.same(oContext), aPromises)
-						.callsFake(function (_sGroupId, _aPaths, _oContext, aPromises) {
-							aPromises.push(Promise.resolve());
-							aPromises.push(Promise.reject(oCanceledError));
+						.callsFake(function (_sGroupId, _aPaths, _oContext, aPromises0) {
+							aPromises0.push(Promise.resolve());
+							aPromises0.push(Promise.reject(oCanceledError));
 							if (bRecursionRejects) {
-								aPromises.push(Promise.reject(oError));
+								aPromises0.push(Promise.reject(oError));
 							}
 						});
 					that.mock(oBinding).expects("refreshDependentListBindingsWithoutCache")