@openui5/sap.ui.core 1.120.1 → 1.120.3

package/test/sap/ui/core/qunit/odata/v4/lib/_AggregationHelper.qunit.js

@@ -170,7 +170,7 @@ sap.ui.define([
 		assert.throws(function () {
 			// code under test
 			_AggregationHelper.beforeOverwritePlaceholder(oPlaceholder, null, oCache, 41);
-		}, new Error("Wrong placeholder"), "index");
+		}, new Error("Wrong placeholder"), "rank");
 
 		assert.throws(function () {
 			// code under test
@@ -1113,6 +1113,7 @@ sap.ui.define([
 		assert.strictEqual(JSON.stringify(mQueryOptions), sQueryOptionsJSON, "unchanged");
 		assert.strictEqual(oAggregation.$NodeProperty, "aNodeID");
 		assert.strictEqual(oAggregation.$ParentNavigationProperty, "aParentNavigation");
+		assert.notOk("$LimitedRank" in oAggregation, "unchanged");
 	});
 });
 
@@ -1133,6 +1134,7 @@ sap.ui.define([
 				$apply : "com.sap.vocabularies.Hierarchy.v1.TopLevels(HierarchyNodes=$root"
 					+ ",HierarchyQualifier='X',NodeProperty='???',Levels=1)"
 			});
+		assert.notOk("$LimitedRank" in oAggregation, "unchanged");
 	});
 
 	//*********************************************************************************************
@@ -1161,21 +1163,37 @@ sap.ui.define([
 				foo : "bar"
 			});
 
+		assert.notOk("$LimitedRank" in oAggregation, "unchanged");
 		assert.notOk("$NodeProperty" in oAggregation);
 		assert.deepEqual(mQueryOptions, {foo : "bar"});
 	});
 
 	//*********************************************************************************************
-[undefined, 1, 2, 3, Number.MAX_SAFE_INTEGER, Infinity].forEach(function (iExpandTo) {
+[undefined, 1, 2, 3, 999, Number.MAX_SAFE_INTEGER, Infinity].forEach(function (iExpandTo) {
 	[false, true].forEach(function (bStored) {
 		[false, true].forEach(function (bAllLevels) {
-			var sTitle = "buildApply4Hierarchy: top levels of nodes, $select, expandTo : "
-				+ iExpandTo + ", property paths already stored: " + bStored
-				+ ", all levels: " + bAllLevels;
-
-			if (iExpandTo >= Number.MAX_SAFE_INTEGER && bAllLevels) {
-				return;
-			}
+			[{
+				DistanceFromRootProperty : {$PropertyPath : "DistFromRoot"},
+				DrillStateProperty : {$PropertyPath : "myDrillState"},
+				LimitedDescendantCountProperty : {$PropertyPath : "LtdDescendant_Count"}
+			}, {
+				DistanceFromRoot : {$Path : "DistFromRoot"},
+				DrillState : {$Path : "myDrillState"},
+				LimitedDescendantCount : {$Path : "LtdDescendant_Count"}
+			}, {
+				DistanceFromRoot : {$Path : "DistFromRoot"},
+				DrillState : {$Path : "myDrillState"},
+				LimitedDescendantCount : {$Path : "LtdDescendant_Count"},
+				LimitedRank : {$Path : "LtdPreorderRank"}
+			}].forEach((oRecursiveHierarchy, i) => {
+				var sTitle = "buildApply4Hierarchy: top levels of nodes, $select, expandTo : "
+					+ iExpandTo + ", property paths already stored: " + bStored
+					+ ", all levels: " + bAllLevels
+					+ ", Rec.Hier. #" + i;
+
+				if (iExpandTo >= 999 && bAllLevels) {
+					return;
+				}
 
 	QUnit.test(sTitle, function (assert) {
 		var oAggregation = {
@@ -1187,12 +1205,9 @@ sap.ui.define([
 			},
 			oAggregationMock = this.mock(oAggregation),
 			oExpectedAggregation = iExpandTo > 1 ? {
-				$DistanceFromRootProperty : "DistFromRoot",
-				$DrillStateProperty : "myDrillState",
-				$LimitedDescendantCountProperty : "LtdDescendant_Count"
-			} : {
-				$DrillStateProperty : "myDrillState"
-			},
+				$DistanceFromRoot : "DistFromRoot",
+				$LimitedDescendantCount : "LtdDescendant_Count"
+			} : {},
 			iExpectedLevels = iExpandTo || 1,
 			aExpectedSelect = iExpandTo > 1
 			? ["ID", "SomeNodeID", "DistFromRoot", "LtdDescendant_Count", "myDrillState"]
@@ -1204,21 +1219,21 @@ sap.ui.define([
 			sQueryOptionsJSON = JSON.stringify(mQueryOptions);
 
 		if (bStored) {
-			oAggregation.$DrillStateProperty = "myDrillState";
+			oAggregation.$DrillState = "myDrillState";
 			oAggregation.$NodeProperty = "SomeNodeID";
 			oAggregation.$ParentNavigationProperty = "SomeParentNavigation";
 		}
 		if (bAllLevels) {
 			aExpectedSelect = ["ID", "SomeNodeID", "DistFromRoot", "myDrillState"];
 			oExpectedAggregation = {
-				$DistanceFromRootProperty : "DistFromRoot"
+				$DistanceFromRoot : "DistFromRoot"
 			};
 			if (bStored) {
-				oAggregation.$DistanceFromRootProperty = "DistFromRoot";
+				oAggregation.$DistanceFromRoot = "DistFromRoot";
 			}
 		} else if (bStored && iExpandTo > 1) {
-			oAggregation.$DistanceFromRootProperty = "DistFromRoot";
-			oAggregation.$LimitedDescendantCountProperty = "LtdDescendant_Count";
+			oAggregation.$DistanceFromRoot = "DistFromRoot";
+			oAggregation.$LimitedDescendantCount = "LtdDescendant_Count";
 		}
 		oAggregationMock.expects("$fetchMetadata").exactly(bStored ? 0 : 1)
 			.withExactArgs("/meta/@Org.OData.Aggregation.V1.RecursiveHierarchy#X")
@@ -1228,18 +1243,14 @@ sap.ui.define([
 			}));
 		oAggregationMock.expects("$fetchMetadata").exactly(bStored ? 0 : 1)
 			.withExactArgs("/meta/@com.sap.vocabularies.Hierarchy.v1.RecursiveHierarchy#X")
-			.returns(SyncPromise.resolve({
-				DistanceFromRootProperty : {$PropertyPath : "DistFromRoot"},
-				DrillStateProperty : {$PropertyPath : "myDrillState"},
-				LimitedDescendantCountProperty : {$PropertyPath : "LtdDescendant_Count"}
-			}));
+			.returns(SyncPromise.resolve(oRecursiveHierarchy));
 		oExpectedAggregation = Object.assign({
 			expandTo : iExpandTo,
 			hierarchyQualifier : "X",
 			$fetchMetadata : oAggregation.$fetchMetadata, // remember the mock(!)
 			$metaPath : "/meta",
 			$path : "/Foo",
-			$DrillStateProperty : "myDrillState",
+			$DrillState : "myDrillState",
 			$NodeProperty : "SomeNodeID",
 			$ParentNavigationProperty : "SomeParentNavigation"
 		}, oExpectedAggregation);
@@ -1248,7 +1259,7 @@ sap.ui.define([
 			// code under test
 			_AggregationHelper.buildApply4Hierarchy(oAggregation, mQueryOptions, bAllLevels),
 			{
-				$apply : bAllLevels || iExpandTo >= Number.MAX_SAFE_INTEGER
+				$apply : bAllLevels || iExpandTo >= 999
 					? "com.sap.vocabularies.Hierarchy.v1.TopLevels(HierarchyNodes=$root/Foo"
 					+ ",HierarchyQualifier='X',NodeProperty='SomeNodeID')"
 					: "com.sap.vocabularies.Hierarchy.v1.TopLevels(HierarchyNodes=$root/Foo"
@@ -1260,8 +1271,17 @@ sap.ui.define([
 
 		assert.strictEqual(JSON.stringify(mQueryOptions), sQueryOptionsJSON, "unchanged");
 		assert.strictEqual(oAggregation.$fetchMetadata, oExpectedAggregation.$fetchMetadata);
+		if (bStored) {
+			assert.notOk("$LimitedRank" in oAggregation, "unchanged");
+		} else {
+			const sLimitedRank
+				= oRecursiveHierarchy.LimitedRank ? "LtdPreorderRank" : "LimitedRank";
+			assert.strictEqual(oAggregation.$LimitedRank, sLimitedRank);
+			oExpectedAggregation.$LimitedRank = sLimitedRank;
+		}
 		assert.deepEqual(oAggregation, oExpectedAggregation);
 	});
+			});
 		});
 	});
 });
@@ -1288,7 +1308,15 @@ sap.ui.define([
 		+ "/orderby(~$orderby~)",
 	mQueryOptions : {$filter : "~$filter~", $orderby : "~$orderby~"}
 }].forEach(function (mFixture, i) {
-	QUnit.test("buildApply4Hierarchy: children of a given parent, #" + i, function (assert) {
+	[
+		{DrillStateProperty : {$PropertyPath : "path/to/aDrillState"}},
+		{DrillState : {$Path : "path/to/aDrillState"}}
+	].forEach((oRecursiveHierarchy, j) => {
+		[false, true].forEach((bStored) => {
+			const sTitle = "buildApply4Hierarchy: children of a given parent, #" + i + ", #" + j
+				+ ", $LimitedRank already stored" + bStored;
+
+	QUnit.test(sTitle, function (assert) {
 		var oAggregation = Object.assign({
 				hierarchyQualifier : "XYZ",
 				$fetchMetadata : function () {},
@@ -1304,6 +1332,9 @@ sap.ui.define([
 			}, mFixture.mQueryOptions),
 			sQueryOptionsJSON = JSON.stringify(mQueryOptions);
 
+		if (bStored) {
+			oAggregation.$LimitedRank = "~LimitedRank~";
+		}
 		oAggregationMock.expects("$fetchMetadata")
 			.withExactArgs("/meta/path/@Org.OData.Aggregation.V1.RecursiveHierarchy#XYZ")
 			.returns(SyncPromise.resolve({
@@ -1312,22 +1343,28 @@ sap.ui.define([
 			}));
 		oAggregationMock.expects("$fetchMetadata")
 			.withExactArgs("/meta/path/@com.sap.vocabularies.Hierarchy.v1.RecursiveHierarchy#XYZ")
-			.returns(SyncPromise.resolve({
-				DrillStateProperty : {$PropertyPath : "aDrillState"}
-			}));
+			.returns(SyncPromise.resolve(oRecursiveHierarchy));
 
 		// code under test
 		assert.deepEqual(_AggregationHelper.buildApply4Hierarchy(oAggregation, mQueryOptions), {
 				$apply : mFixture.sExpectedApply,
 				// no more $filter or $orderby!
-				$select : ["ID", "myID", "aDrillState"],
+				$select : ["ID", "myID", "path/to/aDrillState"],
 				foo : "bar"
 			});
 
 		assert.strictEqual(JSON.stringify(mQueryOptions), sQueryOptionsJSON, "unchanged");
+		if (bStored) {
+			assert.strictEqual(oAggregation.$LimitedRank, "~LimitedRank~", "unchanged");
+		} else {
+			assert.strictEqual(oAggregation.$LimitedRank, "path/to/LimitedRank",
+				"derived from DrillState");
+		}
 		assert.strictEqual(oAggregation.$NodeProperty, "myID");
 		assert.strictEqual(oAggregation.$ParentNavigationProperty, "myParentNavigation");
 	});
+		});
+	});
 });
 
 	//*********************************************************************************************
@@ -1859,7 +1896,7 @@ sap.ui.define([
 			oPlaceholder = _AggregationHelper.createPlaceholder(3, 5, oParentCache);
 
 		assert.strictEqual(oPlaceholder["@$ui5.node.level"], 3);
-		assert.strictEqual(_Helper.getPrivateAnnotation(oPlaceholder, "index"), 5);
+		assert.strictEqual(_Helper.getPrivateAnnotation(oPlaceholder, "rank"), 5);
 		assert.strictEqual(_Helper.getPrivateAnnotation(oPlaceholder, "parent"), oParentCache);
 		assert.strictEqual(_Helper.getPrivateAnnotation(oPlaceholder, "placeholder"), true);
 	});

package/test/sap/ui/core/qunit/odata/v4/lib/_Cache.qunit.js

@@ -228,6 +228,23 @@ sap.ui.define([
 		assert.strictEqual(oCache.sOriginalResourcePath, sResourcePath);
 	});
 
+	//*********************************************************************************************
+	QUnit.test("_Cache#setQueryOptions defaulting", function (assert) {
+		const oCache = new _Cache(this.oRequestor);
+
+		// code under test
+		oCache.setQueryOptions();
+
+		assert.deepEqual(oCache.mQueryOptions, {});
+
+		oCache.bSentRequest = true;
+
+		assert.throws(() => {
+			// code under test
+			oCache.setQueryOptions();
+		}, new Error("Cannot set query options: Cache has already sent a request"));
+	});
+
 	//*********************************************************************************************
 	QUnit.test("_Cache#setResourcePath", function (assert) {
 		var oCache = new _Cache(this.oRequestor, "TEAMS('42')/name.space.Operation");
@@ -424,8 +441,8 @@ sap.ui.define([
 				.withExactArgs(undefined, oFixture.iStatus < 0
 					? [oMessage1, oMessage2] : [oMessage1]);
 			oRestoreExpectation = that.mock(oCache).expects("restoreElement").exactly(iOnFailure)
-				.withExactArgs(sinon.match.same(aCacheData), "~insert~",
-					sinon.match.same(aCacheData[1]), sPath, 2)
+				.withExactArgs("~insert~", sinon.match.same(aCacheData[1]), 2, undefined,
+					sinon.match.same(aCacheData), sPath)
 				.callsFake(() => {
 					assert.deepEqual(aCacheData.$deleted.length, 4);
 				});
@@ -1041,7 +1058,7 @@ sap.ui.define([
 	});
 
 	//*********************************************************************************************
-["", "~path~"].forEach(function (sPath) {
+[undefined, "~path~"].forEach(function (sPath) {
 	[false, true].forEach(function (bTransient) {
 		[false, true].forEach(function (bDefault) {
 			const sTitle = `_Cache#restoreElement, path=${sPath}, transient=${bTransient},
@@ -1057,22 +1074,24 @@ sap.ui.define([
 		if (bDefault) {
 			oCache.aElements = aElements;
 		}
+		const sPath0 = sPath || ""; // to test defaulting
 		this.mock(oCache).expects("adjustIndexes")
-			.withExactArgs(sPath, sinon.match.same(aElements), 42, 1, "~iDeletedIndex~");
+			.withExactArgs(sPath0, sinon.match.same(aElements), 42, 1, "~iDeletedIndex~");
 		const oHelperMock = this.mock(_Helper);
 		oHelperMock.expects("getPrivateAnnotation").exactly(bDefault && bTransient ? 0 : 1)
 			.withExactArgs("~oElement~", "transientPredicate")
 			.returns(bTransient ? "($uid=id-1-23)" : undefined);
 		oHelperMock.expects("addToCount")
-			.withExactArgs(sinon.match.same(oCache.mChangeListeners), sPath,
+			.withExactArgs(sinon.match.same(oCache.mChangeListeners), sPath0,
 				sinon.match.same(aElements), 1);
 		this.mock(aElements).expects("splice").withExactArgs(42, 0, "~oElement~");
 		oHelperMock.expects("getPrivateAnnotation").withExactArgs("~oElement~", "predicate")
 			.returns("~predicate~");
 
 		// code under test
-		oCache.restoreElement(bDefault ? undefined : aElements, 42, "~oElement~", sPath,
-			"~iDeletedIndex~", bDefault && bTransient ? "($uid=id-1-23)" : undefined);
+		oCache.restoreElement(42, "~oElement~", "~iDeletedIndex~",
+			bDefault && bTransient ? "($uid=id-1-23)" : undefined, bDefault ? undefined : aElements,
+			sPath);
 
 		assert.strictEqual(oCache.iLimit, bTransient || sPath ? 234 : 235);
 		assert.strictEqual(aElements.$created, bTransient ? 3 : 2);
@@ -2140,7 +2159,7 @@ sap.ui.define([
 			.withExactArgs("/Products/PostAddress")
 			.returns(SyncPromise.resolve({}));
 		this.mock(_Helper).expects("isSelected")
-			.withExactArgs("PostAddress", undefined)
+			.withExactArgs("PostAddress", {})
 			.returns(false);
 		this.mock(oCache).expects("fetchLateProperty")
 			.withExactArgs("~oGroupLock~", sinon.match.same(oData), "",
@@ -7614,6 +7633,48 @@ sap.ui.define([
 	});
 });
 
+	//*********************************************************************************************
+	QUnit.test("CollectionCache#requestElements: $filter=false", function (assert) {
+		var oCache = this.createCache("Employees", {$filter : "false"}),
+			oCacheMock = this.mock(oCache),
+			oCheckRangeExpectation,
+			iEnd = 10,
+			oFillExpectation,
+			iStart = 0,
+			oHandleResponseExpectation,
+			oPromise,
+			oResult = {"@odata.count" : "0", value : []};
+
+		oCache.bSentRequest = false;
+
+		oCacheMock.expects("getResourcePathWithQuery").never();
+		this.oRequestorMock.expects("request").never();
+		oCacheMock.expects("fetchTypes").withExactArgs().returns(SyncPromise.resolve("~mTypes~"));
+		oFillExpectation = oCacheMock.expects("fill")
+			.withExactArgs(sinon.match.instanceOf(SyncPromise), iStart, iEnd);
+		Promise.resolve().then(function () { // must be called asynchronously
+			oCheckRangeExpectation = oCacheMock.expects("checkRange")
+				.withExactArgs(sinon.match.same(oPromise), iStart, iEnd);
+			oHandleResponseExpectation = oCacheMock.expects("handleResponse")
+				.withExactArgs(oResult, iStart, "~mTypes~")
+				.returns("~iFiltered~");
+			oCacheMock.expects("handleCount")
+				.withExactArgs("~oGroupLock~", 0, iStart, iEnd, oResult, "~iFiltered~");
+		});
+
+		// code under test
+		oPromise = oCache.requestElements(iStart, iEnd, "~oGroupLock~", 0, "~fnDataRequested~");
+
+		assert.deepEqual(oCache.aReadRequests, [{iStart, iEnd}]);
+
+		assert.strictEqual(oCache.bSentRequest, true);
+		assert.strictEqual(oFillExpectation.args[0][0], oPromise);
+
+		return oPromise.then(function () {
+			assert.ok(oCheckRangeExpectation.calledBefore(oHandleResponseExpectation));
+		});
+	});
+
 	//*********************************************************************************************
 	QUnit.test("CollectionCache#checkRange", function (assert) {
 		var oCache = this.createCache("Employees");
@@ -8524,7 +8585,7 @@ sap.ui.define([
 			this.mock(oCountChangeListener).expects("onChange");
 			this.mock(oCache).expects("visitResponse")
 				.withExactArgs(sinon.match.same(oPostResult), sinon.match.same(mTypeForMetaPath),
-					"/TEAMS/TEAM_2_EMPLOYEES", sPathInCache + sTransientPredicate);
+					"/TEAMS/TEAM_2_EMPLOYEES", sPathInCache + sTransientPredicate, undefined, true);
 			// simulate a lack of key predicate => the transient predicate is kept
 			oHelperMock.expects("getPrivateAnnotation")
 				.withExactArgs(sinon.match.same(oPostResult), "predicate")
@@ -9047,7 +9108,7 @@ sap.ui.define([
 			.returns({});
 		oCacheMock.expects("visitResponse")
 			.withExactArgs(sinon.match.same(oPostResult), sinon.match.same(mTypeForMetaPath),
-				"/Employees", sTransientPredicate);
+				"/Employees", sTransientPredicate, undefined, true);
 		oHelperMock.expects("updateSelected")
 			.withExactArgs(sinon.match.same(oCache.mChangeListeners), sTransientPredicate,
 				sinon.match.same(oCache.aElements[0]), sinon.match.same(oPostResult), undefined,
@@ -10280,6 +10341,99 @@ sap.ui.define([
 			});
 	});
 
+	//*********************************************************************************************
+	QUnit.test("CollectionCache#move", function (assert) {
+		const oCache = this.createCache("n/a");
+
+		const aElements = oCache.aElements = ["a", "b", "c", "d", "e", "f", "g", "h"];
+
+		function deepEqual(aExpected) {
+			assert.strictEqual(oCache.aElements, aElements, "same ref");
+			assert.deepEqual(oCache.aElements, aExpected);
+		}
+
+		// code under test (nothing to do)
+		oCache.move(4, 4, 3);
+
+		deepEqual(["a", "b", "c", "d", "e", "f", "g", "h"]);
+
+		// code under test (nothing to do)
+		oCache.move(1, 4, 0);
+
+		deepEqual(["a", "b", "c", "d", "e", "f", "g", "h"]);
+
+		// code under test
+		oCache.move(1, 4, 3);
+
+		deepEqual(["a", "e", "f", "g", /**/"b", "c", "d"/**/, "h"]);
+
+		// code under test (undo)
+		oCache.move(4, 1, 3);
+
+		deepEqual(["a", "b", "c", "d", "e", "f", "g", "h"]);
+
+		// code under test
+		oCache.move(1, 5, 2);
+
+		deepEqual(["a", "d", "e", "f", "g", /**/"b", "c"/**/, "h"]);
+
+		// code under test (undo)
+		oCache.move(5, 1, 2);
+
+		deepEqual(["a", "b", "c", "d", "e", "f", "g", "h"]);
+
+		// code under test
+		oCache.move(1, 3, 4);
+
+		deepEqual(["a", "f", "g", /**/"b", "c", "d", "e"/**/, "h"]);
+
+		// code under test (undo)
+		oCache.move(3, 1, 4);
+
+		deepEqual(["a", "b", "c", "d", "e", "f", "g", "h"]);
+	});
+
+	//*********************************************************************************************
+	QUnit.test("CollectionCache#move: no RangeError", function (assert) {
+		const oCache = this.createCache("n/a");
+
+		for (let i = 0; i < 1_000_000; i += 1) {
+			oCache.aElements[i] = i;
+		}
+
+		// code under test (no "RangeError: Maximum call stack size exceeded")
+		oCache.move(5_000, 10_000, 990_000);
+
+		for (let i = 0; i < 5_000; i += 1) {
+			if (oCache.aElements[i] !== i) {
+				assert.ok(false);
+				break;
+			}
+		}
+		for (let i = 0; i < 990_000; i += 1) {
+			if (oCache.aElements[10_000 + i] !== 5_000 + i) {
+				assert.ok(false);
+				break;
+			}
+		}
+		for (let i = 0; i < 5_000; i += 1) {
+			if (oCache.aElements[5_000 + i] !== 995_000 + i) {
+				assert.ok(false);
+				break;
+			}
+		}
+
+		// code under test (undo)
+		oCache.move(10_000, 5_000, 990_000);
+
+		for (let i = 0; i < 1_000_000; i += 1) {
+			if (oCache.aElements[i] !== i) {
+				assert.ok(false);
+				break;
+			}
+		}
+	});
+
 	//*********************************************************************************************
 [
 	{error : false, path : "EMPLOYEE_2_TEAM"},
@@ -12512,6 +12666,100 @@ sap.ui.define([
 		});
 	});
 
+	//*********************************************************************************************
+	QUnit.test("CollectionCache#read waits for prefetch 'after'", async function (assert) {
+		const oCache = this.createCache("Employees");
+		const oGroupLock = {
+			getUnlockedCopy : mustBeMocked,
+			unlock : mustBeMocked
+		};
+		this.mock(_Helper).expects("getPrivateAnnotation").never();
+		this.mock(this.oRequestor).expects("waitForBatchResponseReceived").never();
+		oCache.aElements.push(...aTestData.slice(0, 5));
+		this.mock(ODataUtils).expects("_getReadIntervals")
+			.withExactArgs(sinon.match.same(oCache.aElements), 0, 5, 10, Infinity)
+			.returns([{
+				end : 15,
+				start : 5 // [0..5[ already available, see above
+			}]);
+		const oGetUnlockedCopyExpectation = this.mock(oGroupLock).expects("getUnlockedCopy")
+			.withExactArgs().returns("~unlockedCopy~");
+		this.mock(oCache).expects("requestElements")
+			.withExactArgs(5, 15, "~unlockedCopy~", 0, "~fnDataRequested~")
+			.callsFake(() => {
+				// just at the edge, there is a promise we need to wait for
+				oCache.aElements[14] = Promise.resolve();
+				// just beyond, there is a promise which never resolves and MUST be ignored
+				oCache.aElements[15] = new Promise(() => {});
+			});
+		const oUnlockExpectation = this.mock(oGroupLock).expects("unlock").withExactArgs();
+
+		// code under test
+		const oSyncPromise = oCache.read(0, 5, 10, oGroupLock, "~fnDataRequested~");
+
+		assert.ok(oSyncPromise.isPending());
+		assert.ok(oUnlockExpectation.calledAfter(oGetUnlockedCopyExpectation));
+
+		await oSyncPromise; // no need to check result, it's defined by aElements way above
+	});
+
+	//*********************************************************************************************
+[10, 30].forEach((iPrefetchLength) => {
+	const sTitle = `CollectionCache#read waits for prefetch 'before', ${iPrefetchLength}`;
+
+	QUnit.test(sTitle, async function (assert) {
+		const oCache = this.createCache("Employees");
+		const oGroupLock = {
+			getUnlockedCopy : mustBeMocked,
+			unlock : mustBeMocked
+		};
+		this.mock(_Helper).expects("getPrivateAnnotation").never();
+		this.mock(this.oRequestor).expects("waitForBatchResponseReceived").never();
+		oCache.aElements.splice(20, 0, ...aTestData.slice(20, 25));
+		oCache.iLimit = 25; // simulate a known $count
+		const iStart = iPrefetchLength === 10 ? 10 : 0; // Math.max(0, 20 - iPrefetchLength)
+		this.mock(ODataUtils).expects("_getReadIntervals")
+			.withExactArgs(sinon.match.same(oCache.aElements), 20, 5, iPrefetchLength, 25)
+			.returns([{
+				end : 20,
+				start : iStart // [20..25[ already available, see above
+			}]);
+		const oGetUnlockedCopyExpectation = this.mock(oGroupLock).expects("getUnlockedCopy")
+			.withExactArgs().returns("~unlockedCopy~");
+		this.mock(oCache).expects("requestElements")
+			.withExactArgs(iStart, 20, "~unlockedCopy~", 0, "~fnDataRequested~")
+			.callsFake(() => {
+				switch (iPrefetchLength) {
+					case 10:
+						// just at the edge, there is a promise we need to wait for
+						oCache.aElements[10] = Promise.resolve();
+						// just beyond, there is a promise which never resolves and MUST be ignored
+						oCache.aElements[9] = new Promise(() => {});
+						break;
+
+					case 30:
+						// just at the edge, there is a promise we need to wait for
+						oCache.aElements[0] = Promise.resolve();
+						// just beyond, there is a promise which never resolves and MUST be ignored
+						oCache.aElements[55] = new Promise(() => {});
+						break;
+
+					default:
+						throw iPrefetchLength;
+				}
+			});
+		const oUnlockExpectation = this.mock(oGroupLock).expects("unlock").withExactArgs();
+
+		// code under test
+		const oSyncPromise = oCache.read(20, 5, iPrefetchLength, oGroupLock, "~fnDataRequested~");
+
+		assert.ok(oSyncPromise.isPending());
+		assert.ok(oUnlockExpectation.calledAfter(oGetUnlockedCopyExpectation));
+
+		await oSyncPromise; // no need to check result, it's defined by aElements way above
+	});
+});
+
 	//*********************************************************************************************
 	QUnit.test("CollectionCache#addKeptElement", function (assert) {
 		var oCache = this.createCache("Employees"),

package/test/sap/ui/core/qunit/odata/v4/lib/_Requestor.qunit.js

@@ -4079,6 +4079,9 @@ sap.ui.define([
 			assert.strictEqual(oBatchQueue0[0].iSerialNumber, 0);
 		}
 
+		const oModelInterfaceMock = this.mock(oModelInterface);
+		oModelInterfaceMock.expects("onCreateGroup").withExactArgs("group");
+
 		// code under test
 		aBatchQueue = oRequestor.getOrCreateBatchQueue("group");
 
@@ -4087,10 +4090,15 @@ sap.ui.define([
 		// code under test
 		assert.strictEqual(oRequestor.getOrCreateBatchQueue("group"), aBatchQueue);
 
-		this.mock(oModelInterface).expects("onCreateGroup").withExactArgs("group2");
+		oModelInterfaceMock.expects("onCreateGroup").withExactArgs("group2");
 
 		// code under test
 		checkBatchQueue(oRequestor.getOrCreateBatchQueue("group2"), "group2");
+
+		oModelInterfaceMock.expects("onCreateGroup").withExactArgs("group3").never();
+
+		// code under test: create queue without informing the model
+		checkBatchQueue(oRequestor.getOrCreateBatchQueue("group3", true), "group3");
 	});
 
 	//*****************************************************************************************
@@ -4110,7 +4118,7 @@ sap.ui.define([
 			aRequests = [aChangeSet0, oGetRequest];
 
 		aRequests.iChangeSet = 0;
-		this.mock(oRequestor).expects("getOrCreateBatchQueue").withExactArgs("group")
+		this.mock(oRequestor).expects("getOrCreateBatchQueue").withExactArgs("group", true)
 			.returns(aRequests);
 		this.mock(oRequestor).expects("getSerialNumber").withExactArgs().returns(42);