@openui5/sap.ui.core 1.117.1 → 1.119.0

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

@@ -375,9 +375,8 @@ sap.ui.define([
 		// "super" call
 		assert.ok(oCache instanceof _AggregationCache, "module value is c'tor function");
 		assert.ok(oCache instanceof _Cache, "_AggregationCache is a _Cache");
-		assert.strictEqual(oCache._delete, null, "disinherit");
 		assert.strictEqual(oCache.addTransientCollection, null, "disinherit");
-		assert.strictEqual(oCache.getAndRemoveValue, null, "disinherit");
+		assert.strictEqual(oCache.getAndRemoveCollection, null, "disinherit");
 		assert.strictEqual(oCache.oRequestor, this.oRequestor);
 		assert.strictEqual(oCache.sResourcePath, sResourcePath);
 		assert.strictEqual(oCache.mQueryOptions, mQueryOptions);
@@ -722,7 +721,8 @@ sap.ui.define([
 [undefined, {}].forEach(function (oParentGroupNode, i) {
 	QUnit.test("createGroupLevelCache: recursive hierarchy, #" + i, function (assert) {
 		var oAggregation = {
-				hierarchyQualifier : "X"
+				hierarchyQualifier : "X",
+				$metaPath : "/meta/path"
 			},
 			oCache = {},
 			mCacheQueryOptions = {},
@@ -737,7 +737,12 @@ sap.ui.define([
 
 		if (oParentGroupNode) {
 			oParentGroupNode["@$ui5.node.level"] = 2;
-			_Helper.setPrivateAnnotation(oParentGroupNode, "filter", "~filter~");
+			this.mock(_Helper).expects("getPrivateAnnotation")
+				.withExactArgs(sinon.match.same(oParentGroupNode), "filter").returns(undefined);
+			this.mock(oAggregationCache).expects("getTypes").withExactArgs().returns("~getTypes~");
+			this.mock(_Helper).expects("getKeyFilter")
+				.withExactArgs(sinon.match.same(oParentGroupNode), "/meta/path", "~getTypes~")
+				.returns("~filter~");
 		}
 		this.mock(_AggregationHelper).expects("getAllProperties").never();
 		this.mock(_AggregationHelper).expects("filterOrderby").never();
@@ -921,14 +926,6 @@ sap.ui.define([
 			.withExactArgs(sinon.match.same(oElement), "B/myDrillState")
 			.returns(sDrillState);
 		oHelperMock.expects("getKeyFilter").never();
-		if (sDrillState === "collapsed") {
-			oHelperMock.expects("getKeyFilter")
-				.withExactArgs(sinon.match.same(oElement), "/meta/path",
-					sinon.match.same(mTypeForMetaPath))
-				.returns("~filter~");
-			oHelperMock.expects("setPrivateAnnotation")
-				.withExactArgs(sinon.match.same(oElement), "filter", "~filter~");
-		}
 		oHelperMock.expects("deleteProperty")
 			.withExactArgs(sinon.match.same(oElement), "B/myDrillState");
 		oHelperMock.expects("drillDown").exactly(oGroupNode ? 0 : 1)
@@ -2244,9 +2241,8 @@ sap.ui.define([
 		oCache.aElements.$byPredicate = {};
 		oCache.aElements.$count = 3;
 
-		oCacheMock.expects("fetchValue").exactly(vHasCache === "expanding" ? 0 : 1)
-			.withExactArgs(sinon.match.same(_GroupLock.$cached), "~path~")
-			.returns(SyncPromise.resolve(oGroupNode));
+		oCacheMock.expects("getValue").exactly(vHasCache === "expanding" ? 0 : 1)
+			.withExactArgs("~path~").returns(oGroupNode);
 		this.mock(_AggregationHelper).expects("getOrCreateExpandedObject")
 			.exactly(vHasCache === "expanding" ? 0 : 1)
 			.withExactArgs(sinon.match.same(oAggregation), sinon.match.same(oGroupNode))
@@ -2385,9 +2381,7 @@ sap.ui.define([
 		oCache.aElements.$byPredicate = {};
 		oCache.aElements.$count = 3;
 
-		this.mock(oCache).expects("fetchValue")
-			.withExactArgs(sinon.match.same(_GroupLock.$cached), "~path~")
-			.returns(SyncPromise.resolve(oGroupNode));
+		this.mock(oCache).expects("getValue").withExactArgs("~path~").returns(oGroupNode);
 		this.mock(_AggregationHelper).expects("getOrCreateExpandedObject")
 			.withExactArgs(sinon.match.same(oAggregation), sinon.match.same(oGroupNode))
 			.returns(oExpanded);
@@ -2465,22 +2459,26 @@ sap.ui.define([
 					cache : oGroupLevelCache,
 					groupLevelCount : 7,
 					spliced : [{
-						"@$ui5._" : {predicate : "('A')"}
+						"@$ui5._" : {predicate : "('A')"},
+						"@$ui5.node.level" : 10
 					}, {
-						"@$ui5._" : {placeholder : true, predicate : "n/a"}
+						"@$ui5._" : {placeholder : true, predicate : "n/a"},
+						"@$ui5.node.level" : 11
 					}, {
-						"@$ui5._" : {expanding : true, predicate : "('C')"}
+						"@$ui5._" : {expanding : true, predicate : "('C')"},
+						"@$ui5.node.level" : 12
 					}]
 				},
 				"@$ui5.node.isExpanded" : false,
-				"@$ui5.node.level" : 0
+				"@$ui5.node.level" : 5
 			},
 			oPromise,
 			aSpliced,
 			oUpdateAllExpectation;
 
 		oGroupNode["@$ui5._"].spliced[200000] = {
-			"@$ui5._" : {predicate : "('D')"}
+			"@$ui5._" : {predicate : "('D')"},
+			"@$ui5.node.level" : 10
 		};
 		aSpliced = oGroupNode["@$ui5._"].spliced.slice();
 		if (bStale) {
@@ -2490,9 +2488,7 @@ sap.ui.define([
 		oCache.aElements = aElements.slice();
 		oCache.aElements.$byPredicate = {};
 		oCache.aElements.$count = 4;
-		oCacheMock.expects("fetchValue")
-			.withExactArgs(sinon.match.same(_GroupLock.$cached), "~path~")
-			.returns(SyncPromise.resolve(oGroupNode));
+		oCacheMock.expects("getValue").withExactArgs("~path~").returns(oGroupNode);
 		oUpdateAllExpectation = this.mock(_Helper).expects("updateAll")
 			.withExactArgs(sinon.match.same(oCache.mChangeListeners), "~path~",
 				sinon.match.same(oGroupNode), {"@$ui5.node.isExpanded" : true})
@@ -2533,11 +2529,15 @@ sap.ui.define([
 			assert.deepEqual(Object.keys(oCache.aElements),
 				["0", "1", "2", "3", "4", "200002", "200003", "200004", "$byPredicate", "$count"]);
 			assert.strictEqual(oCache.aElements[2], aSpliced[0]);
+			assert.strictEqual(aSpliced[0]["@$ui5.node.level"], 6);
 			assert.strictEqual(oCache.aElements[3], aSpliced[1]);
+			assert.strictEqual(aSpliced[1]["@$ui5.node.level"], 7);
 			assert.strictEqual(oCache.aElements[4], aSpliced[2]);
+			assert.strictEqual(aSpliced[2]["@$ui5.node.level"], 8);
 			assert.strictEqual(_Helper.hasPrivateAnnotation(aSpliced[2], "expanding"), bStale,
 				"deleted only if not stale");
 			assert.strictEqual(oCache.aElements[200002], aSpliced[200000]);
+			assert.strictEqual(aSpliced[200000]["@$ui5.node.level"], 6);
 
 			// check moved nodes
 			assert.strictEqual(oCache.aElements[200003], aElements[2]);
@@ -2590,9 +2590,7 @@ sap.ui.define([
 		oCache.aElements.$byPredicate = {};
 		oCache.aElements.$count = 3;
 
-		this.mock(oCache).expects("fetchValue")
-			.withExactArgs(sinon.match.same(_GroupLock.$cached), "~path~")
-			.returns(SyncPromise.resolve(oGroupNode));
+		this.mock(oCache).expects("getValue").withExactArgs("~path~").returns(oGroupNode);
 		oUpdateAllExpectation = this.mock(_Helper).expects("updateAll")
 			.withExactArgs(sinon.match.same(oCache.mChangeListeners), "~path~",
 				sinon.match.same(oGroupNode), {"@$ui5.node.isExpanded" : true})
@@ -2653,9 +2651,7 @@ sap.ui.define([
 			},
 			that = this;
 
-		this.mock(oCache).expects("fetchValue")
-			.withExactArgs(sinon.match.same(_GroupLock.$cached), "~path~")
-			.returns(SyncPromise.resolve(oGroupNode));
+		this.mock(oCache).expects("getValue").withExactArgs("~path~").returns(oGroupNode);
 		this.mock(oCache).expects("createGroupLevelCache")
 			.withExactArgs(sinon.match.same(oGroupNode)).returns(oGroupLevelCache);
 		this.mock(oGroupLevelCache).expects("read")
@@ -2695,7 +2691,7 @@ sap.ui.define([
 			};
 
 		oCache.aElements = [oGroupNode];
-		this.mock(oCache).expects("fetchValue").never();
+		this.mock(oCache).expects("getValue").never();
 		this.mock(_Helper).expects("updateAll").never();
 		this.mock(oCache).expects("createGroupLevelCache").never();
 		this.mock(_AggregationHelper).expects("getCollapsedObject")
@@ -2758,7 +2754,7 @@ sap.ui.define([
 				"@$ui5.node.isExpanded" : true,
 				"@$ui5.node.level" : 5
 			}, {
-				"@$ui5._" : {predicate : "('2')"},
+				"@$ui5._" : {predicate : "('2')", transientPredicate : "($uid=1-23)"},
 				"@$ui5.node.level" : 6 // child
 			}, {
 				"@$ui5._" : {predicate : "('3')"},
@@ -2800,12 +2796,11 @@ sap.ui.define([
 			"('0')" : aElements[0],
 			"('1')" : aElements[1],
 			"('2')" : aElements[2],
+			"($uid=1-23)" : aElements[2],
 			"('3')" : aElements[3],
 			"('4')" : aElements[4]
 		};
-		this.mock(oCache).expects("fetchValue")
-			.withExactArgs(sinon.match.same(_GroupLock.$cached), "~path~")
-			.returns(SyncPromise.resolve(aElements[1]));
+		this.mock(oCache).expects("getValue").withExactArgs("~path~").returns(aElements[1]);
 		this.mock(_Helper).expects("updateAll")
 			.withExactArgs(sinon.match.same(oCache.mChangeListeners), "~path~",
 				sinon.match.same(aElements[1]), sinon.match.same(oCollapsed))
@@ -2855,9 +2850,7 @@ sap.ui.define([
 			}];
 
 		oCache.aElements = aElements.slice(); // simulate a read
-		this.mock(oCache).expects("fetchValue")
-			.withExactArgs(sinon.match.same(_GroupLock.$cached), "~path~")
-			.returns(SyncPromise.resolve(aElements[0]));
+		this.mock(oCache).expects("getValue").withExactArgs("~path~").returns(aElements[0]);
 		this.mock(_AggregationHelper).expects("getCollapsedObject")
 			.withExactArgs(sinon.match.same(aElements[0])).returns(oCollapsed);
 		this.mock(_Helper).expects("getPrivateAnnotation")
@@ -2928,9 +2921,7 @@ sap.ui.define([
 				aSpliced.push(oPlaceholder);
 			}
 		}
-		this.mock(oCache).expects("fetchValue")
-			.withExactArgs(sinon.match.same(_GroupLock.$cached), "~path~")
-			.returns(SyncPromise.resolve(aElements[0]));
+		this.mock(oCache).expects("getValue").withExactArgs("~path~").returns(aElements[0]);
 		// don't care about getCollapsedObject and updateAll here
 
 		// code under test
@@ -2998,9 +2989,7 @@ sap.ui.define([
 			"('2')" : aElements[2],
 			"('3')" : aElements[3]
 		};
-		this.mock(oCache).expects("fetchValue")
-			.withExactArgs(sinon.match.same(_GroupLock.$cached), "~path~")
-			.returns(SyncPromise.resolve(aElements[0]));
+		this.mock(oCache).expects("getValue").withExactArgs("~path~").returns(aElements[0]);
 		// don't care about getCollapsedObject and updateAll here
 
 		// code under test
@@ -3718,15 +3707,165 @@ sap.ui.define([
 		assert.strictEqual(aResult[1], aElements[2]);
 	});
 
+	//*********************************************************************************************
+[false, true].forEach((bTransient) => {
+	[0, 1].forEach((iOldSiblingCount) => {
+		[false, true].forEach((bParentHasCache) => {
+			const sTitle = `move: already transient = ${bTransient},
+ old sibling count = ${iOldSiblingCount}, new parent already has cache = ${bParentHasCache}`;
+
+	QUnit.test(sTitle, function (assert) {
+		const oCache = _AggregationCache.create(this.oRequestor, "n/a", "", {}, {
+				$ParentNavigationProperty : "myParent",
+				hierarchyQualifier : "X"
+			});
+		const oOldParent = {"@$ui5.node.isExpanded" : "n/a"};
+		const oParentNode = {"@$ui5.node.level" : 9};
+		oCache.aElements = ["a", oOldParent, "~oChildNode~", "d", "e", "f", "g", oParentNode, "i"];
+		oCache.aElements.$byPredicate = {
+			"('23')" : "~oChildNode~",
+			"('42')" : oParentNode
+		};
+		const oRequestExpectation = this.mock(this.oRequestor).expects("request")
+			.withExactArgs("PATCH", "Foo('23')", "~oGroupLock~", {
+					"If-Match" : "~oChildNode~",
+					Prefer : "return=minimal"
+				}, {"myParent@odata.bind" : "Foo('42')"},
+				/*fnSubmit*/null, /*fnCancel*/sinon.match.func)
+			.resolves({"@odata.etag" : "etag"});
+		const oHelperMock = this.mock(_Helper);
+		oHelperMock.expects("updateExisting")
+			.withExactArgs(sinon.match.same(oCache.mChangeListeners), "('23')", "~oChildNode~",
+				{"@odata.etag" : "etag"});
+		const oCacheMock = this.mock(oCache);
+		oCacheMock.expects("shiftIndex").withExactArgs(2, -1).callsFake(function () {
+				assert.deepEqual(oCache.aElements,
+					["a", oOldParent, "~oChildNode~", "d", "e", "f", "g", oParentNode, "i"]);
+			});
+		const oOldParentCache = {
+			getValue : mustBeMocked,
+			removeElement : mustBeMocked,
+			setActive : mustBeMocked
+		};
+		oHelperMock.expects("getPrivateAnnotation").withExactArgs("~oChildNode~", "parent")
+			.returns(oOldParentCache);
+		oHelperMock.expects("getPrivateAnnotation").withExactArgs("~oChildNode~", "index")
+			.returns("~index~");
+		this.mock(oOldParentCache).expects("removeElement")
+			.withExactArgs(undefined, "~index~", "('23')", "");
+		this.mock(oOldParentCache).expects("getValue").withExactArgs("$count")
+			.returns(iOldSiblingCount);
+		oHelperMock.expects("getPrivateAnnotation").exactly(iOldSiblingCount ? 0 : 1)
+			.withExactArgs(sinon.match.same(oOldParent), "predicate").returns("('b')");
+		oHelperMock.expects("updateAll").exactly(iOldSiblingCount ? 0 : 1)
+			.withExactArgs(sinon.match.same(oCache.mChangeListeners), "('b')",
+				sinon.match.same(oOldParent), {"@$ui5.node.isExpanded" : undefined});
+		oHelperMock.expects("deletePrivateAnnotation").exactly(iOldSiblingCount ? 0 : 1)
+			.withExactArgs(sinon.match.same(oOldParent), "cache");
+		this.mock(oOldParentCache).expects("setActive").exactly(iOldSiblingCount ? 0 : 1)
+			.withExactArgs(false);
+		oHelperMock.expects("hasPrivateAnnotation")
+			.withExactArgs("~oChildNode~", "transientPredicate").returns(bTransient);
+		oHelperMock.expects("uid").exactly(bTransient ? 0 : 1).withExactArgs().returns("1-23");
+		oHelperMock.expects("setPrivateAnnotation").exactly(bTransient ? 0 : 1)
+			.withExactArgs("~oChildNode~", "transientPredicate", "($uid=1-23)");
+		oHelperMock.expects("updateAll").exactly(bTransient ? 0 : 1)
+			.withExactArgs(sinon.match.same(oCache.mChangeListeners), "('23')", "~oChildNode~",
+				{"@$ui5.context.isTransient" : false});
+		const oParentCache = {
+			restoreElement : mustBeMocked,
+			setEmpty : mustBeMocked
+		};
+		oHelperMock.expects("getPrivateAnnotation")
+			.withExactArgs(sinon.match.same(oParentNode), "cache")
+			.returns(bParentHasCache ? oParentCache : undefined);
+		oCacheMock.expects("createGroupLevelCache").exactly(bParentHasCache ? 0 : 1)
+			.withExactArgs(sinon.match.same(oParentNode)).returns(oParentCache);
+		this.mock(oParentCache).expects("setEmpty").exactly(bParentHasCache ? 0 : 1)
+			.withExactArgs();
+		oHelperMock.expects("setPrivateAnnotation").exactly(bParentHasCache ? 0 : 1)
+			.withExactArgs(sinon.match.same(oParentNode), "cache", sinon.match.same(oParentCache));
+		oHelperMock.expects("updateAll").exactly(bParentHasCache ? 0 : 1)
+			.withExactArgs(sinon.match.same(oCache.mChangeListeners), "('42')",
+				sinon.match.same(oParentNode), {"@$ui5.node.isExpanded" : true});
+		this.mock(oParentCache).expects("restoreElement")
+			.withExactArgs(undefined, 0, "~oChildNode~", "");
+		oHelperMock.expects("setPrivateAnnotation").withExactArgs("~oChildNode~", "index", 0);
+		const oParentExpectation = oHelperMock.expects("setPrivateAnnotation")
+			.withExactArgs("~oChildNode~", "parent", sinon.match.same(oParentCache));
+		const oNodeLevelExpectation = oHelperMock.expects("updateAll")
+			.withExactArgs(sinon.match.same(oCache.mChangeListeners), "('23')", "~oChildNode~",
+				{"@$ui5.node.level" : 10});
+		oCacheMock.expects("shiftIndex").withExactArgs(7, +1).callsFake(function () {
+				assert.deepEqual(oCache.aElements,
+					["a", oOldParent, "d", "e", "f", "g", oParentNode, "~oChildNode~", "i"]);
+				// 'relies on "parent" & "@$ui5.node.level"!'
+				assert.strictEqual(oParentExpectation.callCount, 1);
+				assert.strictEqual(oNodeLevelExpectation.callCount, 1);
+			});
+
+		// code under test
+		return oCache.move("~oGroupLock~", "Foo('23')", "Foo('42')")
+			.then(function (vResult) {
+				assert.strictEqual(vResult, undefined, "without a defined result");
+				assert.deepEqual(oCache.aElements,
+					["a", oOldParent, "d", "e", "f", "g", oParentNode, "~oChildNode~", "i"]);
+				assert.deepEqual(oCache.aElements.$byPredicate, bTransient ? {
+						"('23')" : "~oChildNode~",
+						"('42')" : oParentNode
+					} : {
+						"($uid=1-23)" : "~oChildNode~",
+						"('23')" : "~oChildNode~",
+						"('42')" : oParentNode
+					});
+				assert.deepEqual(oOldParent,
+					iOldSiblingCount ? {"@$ui5.node.isExpanded" : "n/a"} : {});
+
+				// code under test (invoke fnCancel which does nothing)
+				oRequestExpectation.args[0][6]();
+			});
+	});
+		});
+	});
+});
+
+	//*********************************************************************************************
+	QUnit.test("move: failure", function (assert) {
+		const oCache = _AggregationCache.create(this.oRequestor, "n/a", "", {}, {
+				$ParentNavigationProperty : "myParent",
+				hierarchyQualifier : "X"
+			});
+		oCache.aElements.$byPredicate["('23')"] = "~oChildNode~";
+		const oError = new Error("This call intentionally failed");
+		this.mock(this.oRequestor).expects("request")
+			.withExactArgs("PATCH", "Foo('23')", "~oGroupLock~", {
+					"If-Match" : "~oChildNode~",
+					Prefer : "return=minimal"
+				}, {"myParent@odata.bind" : "Foo('42')"},
+				/*fnSubmit*/null, /*fnCancel*/sinon.match.func)
+			.rejects(oError);
+
+		// code under test
+		return oCache.move("~oGroupLock~", "Foo('23')", "Foo('42')")
+			.then(function () {
+				assert.ok(false, "unexpected success");
+			}, function (oError0) {
+				assert.strictEqual(oError0, oError);
+			});
+	});
+
 	//*********************************************************************************************
 [false, true].forEach(function (bHasGroupLevelCache) {
 	QUnit.test("create: already has group level cache: " + bHasGroupLevelCache, function (assert) {
+		var fnCancelCallback;
+
 		const oCache = _AggregationCache.create(this.oRequestor, "Foo", "", {}, {
 				$ParentNavigationProperty : "myParent",
 				hierarchyQualifier : "X"
 			});
 		const oGroupLevelCache = {
-				create : mustBeMocked
+				create : mustBeMocked,
+				setEmpty : mustBeMocked
 			};
 		const oParentNode = {
 				"@$ui5._" : {cache : bHasGroupLevelCache ? oGroupLevelCache : undefined},
@@ -3735,8 +3874,11 @@ sap.ui.define([
 		oCache.aElements = ["0", "1", oParentNode, "3", "4"];
 		oCache.aElements.$byPredicate = {"('42')" : oParentNode};
 		oCache.aElements.$count = 5;
-		this.mock(oCache).expects("createGroupLevelCache").exactly(bHasGroupLevelCache ? 0 : 1)
+		const oCacheMock = this.mock(oCache);
+		oCacheMock.expects("createGroupLevelCache").exactly(bHasGroupLevelCache ? 0 : 1)
 			.withExactArgs(sinon.match.same(oParentNode)).returns(oGroupLevelCache);
+		this.mock(oGroupLevelCache).expects("setEmpty").exactly(bHasGroupLevelCache ? 0 : 1)
+			.withExactArgs();
 		this.mock(_Helper).expects("updateAll").exactly(bHasGroupLevelCache ? 0 : 1)
 			.withExactArgs(sinon.match.same(oCache.mChangeListeners), "('42')",
 				sinon.match.same(oParentNode), {"@$ui5.node.isExpanded" : true});
@@ -3749,8 +3891,9 @@ sap.ui.define([
 		this.mock(oGroupLevelCache).expects("create")
 			.withExactArgs("~oGroupLock~", "~oPostPathPromise~", "~sPath~", "~sTransientPredicate~",
 				{bar : "~bar~", foo : "~foo~"},
-				false, "~fnErrorCallback~", "~fnSubmitCallback~")
-			.callsFake(() => {
+				false, "~fnErrorCallback~", "~fnSubmitCallback~", sinon.match.func)
+			.callsFake(function () {
+				fnCancelCallback = arguments[8];
 				if (!bHasGroupLevelCache) {
 					assert.strictEqual(_Helper.getPrivateAnnotation(oParentNode, "cache"),
 						oGroupLevelCache);
@@ -3763,18 +3906,21 @@ sap.ui.define([
 					});
 				});
 			});
-		this.mock(oCache).expects("addElements")
+		this.mock(_Helper).expects("makeRelativeUrl").withExactArgs("/Foo('42')", "/Foo")
+			.returns("~relativeUrl~");
+		oCacheMock.expects("addElements")
 			.withExactArgs(sinon.match.same(oEntityData), 3, sinon.match.same(oGroupLevelCache), 0)
 			.callsFake(function () {
 				assert.deepEqual(oCache.aElements, ["0", "1", oParentNode, null, "3", "4"]);
 			});
+		oCacheMock.expects("shiftIndex").withExactArgs(3, +1);
 
 		// code under test
 		const oResult = oCache.create("~oGroupLock~", "~oPostPathPromise~", "~sPath~",
 			"~sTransientPredicate~", oEntityData, /*bAtEndOfCreated*/false, "~fnErrorCallback~",
 			"~fnSubmitCallback~");
 
-		assert.deepEqual(oPostBody, {"myParent@odata.bind" : "Foo('42')"});
+		assert.deepEqual(oPostBody, {"myParent@odata.bind" : "~relativeUrl~"});
 		assert.deepEqual(oEntityData, {
 			"@$ui5._" : {postBody : oPostBody},
 			"@$ui5.node.level" : 24,
@@ -3790,7 +3936,27 @@ sap.ui.define([
 				"('42')" : oParentNode,
 				"('ABC')" : oEntityData
 			});
-		});
+			assert.strictEqual(oCache.aElements.$count, 6);
+
+			oCache.aElements[3] = oEntityData;
+			oCacheMock.expects("shiftIndex").withExactArgs(3, -1)
+				.callsFake(function () {
+					assert.deepEqual(oCache.aElements,
+						["0", "1", oParentNode, oEntityData, "3", "4"], "not yet spliced");
+				});
+			this.mock(_Helper).expects("getPrivateAnnotation")
+				.withExactArgs(sinon.match.same(oEntityData), "transientPredicate")
+				.returns("('42')"); // just testing ;-)
+
+			// code under test
+			fnCancelCallback();
+
+			assert.strictEqual(oCache.aElements.$count, 5);
+			assert.deepEqual(oCache.aElements.$byPredicate, {
+				"('ABC')" : oEntityData
+			});
+			assert.deepEqual(oCache.aElements, ["0", "1", oParentNode, "3", "4"]);
+		}.bind(this));
 	});
 });
 
@@ -3828,4 +3994,229 @@ sap.ui.define([
 			oCache.create(null, null, "", "", {"@$ui5.node.parent" : "Foo('42')"});
 		}, new Error("Unsupported collapsed parent: Foo('42')"));
 	});
+
+	//*********************************************************************************************
+[false, true].forEach(function (bBreak) {
+	QUnit.test(`shiftIndex: break = ${bBreak}`, function (assert) {
+		const oCache = _AggregationCache.create(this.oRequestor, "Foo", "", {}, {
+				hierarchyQualifier : "X"
+			});
+		const oNode = {
+				"@$ui5._" : {parent : "~oGroupLevelCache~"},
+				"@$ui5.node.level" : 24,
+				ID : "node"
+			};
+		const oElementSkip = {
+				"@$ui5._" : {index : -3, parent : "not oGroupLevelCache", placeholder : true},
+				"@$ui5.node.level" : 0, // must be ignored
+				ID : "skip"
+			};
+		const oElementNoBreak = {
+				"@$ui5.node.level" : 24,
+				ID : "no break"
+			};
+		const oElementChange = {
+				"@$ui5._" : {index : 4, parent : "~oGroupLevelCache~"},
+				"@$ui5.node.level" : 24,
+				ID : "change (node)"
+			};
+		const oPlaceholderChange = {
+				"@$ui5._" : {index : 5, parent : "~oGroupLevelCache~", placeholder : true},
+				"@$ui5.node.level" : 0, // must be ignored
+				ID : "change (placeholder)"
+			};
+		const oElementBreak = {
+				"@$ui5.node.level" : bBreak
+					? 23 // looks like sibling of oNode's parent
+					: 24, // no break here (check that for-loop does not "overshoot")
+				ID : "break"
+			};
+		const oElementTrap = { // this is unrealistic and acts as a trap to prove that loop ends
+				"@$ui5._" : {index : 7, parent : "~oGroupLevelCache~", placeholder : true},
+				"@$ui5.node.level" : 0, // must be ignored
+				ID : "trap"
+			};
+		oCache.aElements = ["0", "1", oNode, oElementSkip, oElementNoBreak, oElementChange,
+			oPlaceholderChange, oElementBreak, oElementTrap];
+
+		// code under test
+		oCache.shiftIndex(2, 47);
+
+		assert.deepEqual(oCache.aElements, ["0", "1", {
+			"@$ui5._" : {parent : "~oGroupLevelCache~"},
+			"@$ui5.node.level" : 24,
+			ID : "node"
+		}, {
+			"@$ui5._" : {index : -3, parent : "not oGroupLevelCache", placeholder : true},
+			"@$ui5.node.level" : 0,
+			ID : "skip"
+		}, {
+			"@$ui5.node.level" : 24,
+			ID : "no break"
+		}, {
+			"@$ui5._" : {index : 4 + 47, parent : "~oGroupLevelCache~"},
+			"@$ui5.node.level" : 24,
+			ID : "change (node)"
+		}, {
+			"@$ui5._" : {index : 5 + 47, parent : "~oGroupLevelCache~", placeholder : true},
+			"@$ui5.node.level" : 0,
+			ID : "change (placeholder)"
+		}, {
+			"@$ui5.node.level" : bBreak ? 23 : 24,
+			ID : "break"
+		}, {
+			"@$ui5._" : {
+				index : bBreak ? /*unchanged!*/7 : 7 + 47,
+				parent : "~oGroupLevelCache~",
+				placeholder : true
+			},
+			"@$ui5.node.level" : 0,
+			ID : "trap"
+		}]);
+	});
+});
+
+	//*********************************************************************************************
+[
+	{parentLeaf : false, parentExpand : true},
+	{parentLeaf : false, parentExpand : false, parentMoved : true},
+	{parentLeaf : true, parentExpand : false},
+	{noParent : true}
+].forEach(function (oFixture) {
+	QUnit.test(`_delete: leaf, ${JSON.stringify(oFixture)}`, function (assert) {
+		// Before the delete, the child is at 2 and the parent is at 1 (or missing) - hence the
+		// child's level index is 0 (or 2). When restoring, the level index is 3, and the parent
+		// possibly moved to index 6. So the child must be restored to 3 (no parent), 5 (parent
+		// still at 1) or 10 (parent moved to 6).
+		const oCache = _AggregationCache.create(this.oRequestor, "Foo", "", {}, {
+			hierarchyQualifier : "X"
+		});
+		const fnCallback = sinon.spy();
+		const oLevelCache = {
+			_delete : mustBeMocked,
+			getValue : mustBeMocked
+		};
+		const oParent = {
+			"@$ui5.node.isExpanded" : true
+		};
+
+		if (!oFixture.noParent) {
+			oCache.aElements[1] = oParent;
+		}
+		oCache.aElements[2] = "~oElement~";
+		const oHelperMock = this.mock(_Helper);
+		oHelperMock.expects("getPrivateAnnotation").withExactArgs("~oElement~", "parent")
+			.returns(oLevelCache);
+		oHelperMock.expects("getPrivateAnnotation").withExactArgs("~oElement~", "index")
+			.returns(oFixture.noParent ? 2 : 0);
+		const oLevelCacheMock = this.mock(oLevelCache);
+		const oDeleteExpectation = oLevelCacheMock.expects("_delete")
+			.withExactArgs("~groupLock~", "~editUrl~", oFixture.noParent ? "2" : "0",
+				"~etagEntity~", sinon.match.func)
+			.returns("~promise~");
+
+		assert.strictEqual(
+			// code under test
+			oCache._delete("~groupLock~", "~editUrl~", "2", "~etagEntity~", fnCallback),
+			"~promise~");
+
+		const oCacheMock = this.mock(oCache);
+		const oShiftExpectation1 = oCacheMock.expects("shiftIndex").withExactArgs(2, -1);
+		oHelperMock.expects("getPrivateAnnotation").withExactArgs("~oElement~", "predicate")
+			.returns("~predicate~");
+		const oRemoveExpectation = oCacheMock.expects("removeElement")
+			.withExactArgs(sinon.match.same(oCache.aElements), 2, "~predicate~", "");
+		oLevelCacheMock.expects("getValue").exactly(oFixture.noParent ? 0 : 1)
+			.withExactArgs("$count").returns(oFixture.parentLeaf ? 0 : 5);
+		oHelperMock.expects("getPrivateAnnotation").exactly(oFixture.parentLeaf ? 1 : 0)
+			.withExactArgs(sinon.match.same(oParent), "predicate").returns("~predicate~");
+		oHelperMock.expects("updateAll").exactly(oFixture.parentLeaf ? 1 : 0)
+			.withExactArgs(sinon.match.same(oCache.mChangeListeners), "~predicate~",
+				sinon.match.same(oParent), {"@$ui5.node.isExpanded" : undefined});
+
+		// code under test - callback deleting
+		oDeleteExpectation.firstCall.args[4](0, -1);
+
+		if (oFixture.parentMoved) {
+			delete oCache.aElements[1];
+			oCache.aElements[6] = oParent;
+		}
+		assert.ok(oShiftExpectation1.calledBefore(oRemoveExpectation));
+		assert.strictEqual(fnCallback.callCount, 1);
+		assert.deepEqual(fnCallback.args[0], [2, -1]);
+		if (oFixture.parentLeaf) {
+			assert.notOk("@$ui5.node.isExpanded" in oParent);
+		}
+
+		// parent index is 6 or 1, child index in level cache is 3 (from the callback)
+		let iExpectedIndex = oFixture.parentMoved ? 10 : 5;
+		if (oFixture.noParent) {
+			iExpectedIndex = 3;
+		}
+		const oRestoreExpectation = this.mock(oCache).expects("restoreElement")
+			.withExactArgs(sinon.match.same(oCache.aElements), iExpectedIndex, "~oElement~", "");
+		const oShiftExpectation2 = oCacheMock.expects("shiftIndex")
+			.withExactArgs(iExpectedIndex, 1);
+		oLevelCacheMock.expects("getValue").exactly(oFixture.noParent ? 0 : 1)
+			.withExactArgs("$count").returns(oFixture.parentExpand ? 1 : 5);
+		oHelperMock.expects("getPrivateAnnotation").exactly(oFixture.parentExpand ? 1 : 0)
+			.withExactArgs(sinon.match.same(oParent), "predicate").returns("~predicate~");
+		oHelperMock.expects("updateAll").exactly(oFixture.parentExpand ? 1 : 0)
+			.withExactArgs(sinon.match.same(oCache.mChangeListeners), "~predicate~",
+				sinon.match.same(oParent), {"@$ui5.node.isExpanded" : true});
+		oHelperMock.expects("setPrivateAnnotation").withExactArgs("~oElement~", "index", 3);
+
+		// code under test - callback reinserting
+		oDeleteExpectation.firstCall.args[4](3, 1);
+
+		assert.ok(oRestoreExpectation.calledBefore(oShiftExpectation2));
+		assert.strictEqual(fnCallback.callCount, 2);
+		assert.deepEqual(fnCallback.args[1], [iExpectedIndex, 1]);
+	});
+});
+
+	//*********************************************************************************************
+	QUnit.test("_delete: expandTo > 1", function (assert) {
+		const oCache = _AggregationCache.create(this.oRequestor, "Foo", "", {}, {
+				expandTo : 2,
+				hierarchyQualifier : "X"
+			});
+		this.mock(oCache).expects("removeElement").never();
+		this.mock(_Helper).expects("updateAll").never();
+
+		assert.throws(function () {
+			oCache._delete();
+		}, new Error("Unsupported expandTo: 2"));
+	});
+
+	//*********************************************************************************************
+	QUnit.test("_delete: kept-alive not in collection", function (assert) {
+		const oCache = _AggregationCache.create(this.oRequestor, "Foo", "", {}, {
+				hierarchyQualifier : "X"
+			});
+		this.mock(oCache).expects("removeElement").never();
+		this.mock(_Helper).expects("updateAll").never();
+
+		assert.throws(function () {
+			oCache._delete("~oGroupLock~", "~sEditUrl~", "('1')");
+		}, new Error("Unsupported kept-alive entity: Foo('1')"));
+	});
+
+	//*********************************************************************************************
+	QUnit.test("resetChangesForPath", function () {
+		const oCache = _AggregationCache.create(this.oRequestor, "Foo", "", {}, {
+			hierarchyQualifier : "X"
+		});
+		const oElementCache = {
+			resetChangesForPath : mustBeMocked
+		};
+
+		this.mock(oCache).expects("getValue").withExactArgs("~sPath~").returns("~oElement~");
+		this.mock(_Helper).expects("getPrivateAnnotation").withExactArgs("~oElement~", "parent")
+			.returns(oElementCache);
+		this.mock(oElementCache).expects("resetChangesForPath").withExactArgs("~sPath~");
+
+		// code under test
+		oCache.resetChangesForPath("~sPath~");
+	});
 });