@openui5/sap.ui.core 1.117.1 → 1.119.0

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

@@ -384,12 +384,10 @@ sap.ui.define([
 				"@odata.etag" : sEtag
 			}, {}],
 			fnCallback = this.spy(),
-			oCountExpectation,
 			oDeleted = {index : "~insert~"},
 			oError = new Error(""),
 			oGroupLock = {getGroupId : function () {}},
 			oHelperMock = this.mock(_Helper),
-			oIndexExpectation,
 			oMessage1 = {code : "CODE1"},
 			oMessage2 = {code : "CODE2", persistent : true},
 			oMessageExpectation,
@@ -398,14 +396,12 @@ sap.ui.define([
 			oPromise,
 			oRequestExpectation,
 			oRequestPromise,
-			oSpliceExpectation,
+			oRestoreExpectation,
 			bSuccess = oFixture.iStatus === 200 || oFixture.iStatus === 404;
 
 		function checkCleanedUp() {
 			assert.notOk("@$ui5.context.isDeleted" in aCacheData[1]);
 			assert.deepEqual(aCacheData.$deleted, ["a", "b", "c"]);
-			assert.strictEqual(aCacheData.$created, oFixture.bCreated ? 2 : 1);
-			assert.strictEqual(oCache.iActiveElements, oFixture.bCreated && !sPath ? 2 : 1);
 			if (oFixture.bInactive) {
 				sinon.assert.calledOnceWithExactly(fnCallback, 1, -1);
 			} else {
@@ -427,16 +423,12 @@ sap.ui.define([
 				.exactly(oFixture.bMessagesToRestore ? 1 : 0)
 				.withExactArgs(undefined, oFixture.iStatus < 0
 					? [oMessage1, oMessage2] : [oMessage1]);
-			aCacheData.$count = 2; // ensure that count is updated
-			oCountExpectation = oHelperMock.expects("addToCount").exactly(iOnFailure)
-				.withExactArgs(sinon.match.same(oCache.mChangeListeners), sPath,
-					sinon.match.same(aCacheData), 1);
-			aCacheData.$created = 1;
-			oCache.iActiveElements = 1;
-			oSpliceExpectation = that.mock(aCacheData).expects("splice").exactly(iOnFailure)
-				.withExactArgs("~insert~", 0, sinon.match.same(aCacheData[1]));
-			oIndexExpectation = that.mock(oCache).expects("adjustIndexes").exactly(iOnFailure)
-				.withExactArgs(sPath, sinon.match.same(aCacheData), "~insert~", 1, 2);
+			oRestoreExpectation = that.mock(oCache).expects("restoreElement").exactly(iOnFailure)
+				.withExactArgs(sinon.match.same(aCacheData), "~insert~",
+					sinon.match.same(aCacheData[1]), sPath, 2)
+				.callsFake(() => {
+					assert.deepEqual(aCacheData.$deleted.length, 4);
+				});
 			if (oFixture.iStatus !== 200) {
 				if (oFixture.iStatus < 0) { // simulate the cancel
 					oError.canceled = true;
@@ -445,9 +437,7 @@ sap.ui.define([
 					oRequestExpectation.args[0][6]();
 
 					assert.strictEqual(oMessageExpectation.called, !!oFixture.bMessagesToRestore);
-					assert.ok(oCountExpectation.called);
-					assert.ok(oSpliceExpectation.called);
-					assert.ok(oIndexExpectation.called);
+					assert.ok(oRestoreExpectation.called);
 					checkCleanedUp();
 				}
 				throw oError;
@@ -462,9 +452,6 @@ sap.ui.define([
 		this.mock(oCache).expects("fetchValue")
 			.withExactArgs(sinon.match.same(_GroupLock.$cached), sPath)
 			.returns(SyncPromise.resolve(aCacheData));
-		this.mock(_Cache).expects("from$skip")
-			.withExactArgs(oFixture.bCreated ? "-1" : "0", sinon.match.same(aCacheData))
-			.returns(1);
 		oError.status = oFixture.iStatus;
 		oHelperMock.expects("getPrivateAnnotation")
 			.withExactArgs(aCacheData[1], "predicate").callThrough();
@@ -507,9 +494,8 @@ sap.ui.define([
 				sinon.match.same(oRequestPromise));
 
 		// code under test
-		oPromise = oCache._delete(oGroupLock, "Equipments('1')",
-			(sPath && sPath + "/") + (oFixture.bCreated ? "-1" : "0"), oFixture.oEntity,
-			fnCallback);
+		oPromise = oCache._delete(oGroupLock, "Equipments('1')", (sPath && sPath + "/") + "1",
+			oFixture.oEntity, fnCallback);
 
 		assert.strictEqual(aCacheData[1]["@$ui5.context.isDeleted"], true);
 		sinon.assert.calledOnceWithExactly(fnCallback, 1, -1);
@@ -605,8 +591,7 @@ sap.ui.define([
 		};
 
 		oCache.fetchValue = function () {};
-		aCacheData.$count = 2; // ensure that count is not updated
-		this.mock(_Helper).expects("setCount").never();
+		this.mock(oCache).expects("restoreElement").never();
 		this.mock(oCache).expects("fetchValue")
 			.withExactArgs(sinon.match.same(_GroupLock.$cached), "")
 			.returns(SyncPromise.resolve(aCacheData));
@@ -670,9 +655,6 @@ sap.ui.define([
 		this.mock(oCache).expects("fetchValue")
 			.withExactArgs(sinon.match.same(_GroupLock.$cached), "EMPLOYEE_2_EQUIPMENTS")
 			.returns(SyncPromise.resolve(aCacheData));
-		this.mock(_Cache).expects("from$skip")
-			.withExactArgs("1", sinon.match.same(aCacheData))
-			.returns(1);
 		// not interested in buildQueryString
 		this.oRequestorMock.expects("request").never();
 		this.mock(oCache).expects("requestCount").never();
@@ -721,8 +703,6 @@ sap.ui.define([
 		this.mock(oCache).expects("fetchValue")
 			.withExactArgs(sinon.match.same(_GroupLock.$cached), "SO_2_SOITEM")
 			.returns(SyncPromise.resolve(aElements));
-		this.mock(_Cache).expects("from$skip").withExactArgs("-1", sinon.match.same(aElements))
-			.returns(1);
 		oHelperMock.expects("getPrivateAnnotation")
 			.withExactArgs(sinon.match.same(oElement), "predicate").returns("n/a");
 		oHelperMock.expects("getPrivateAnnotation")
@@ -738,7 +718,7 @@ sap.ui.define([
 			.withExactArgs(sinon.match.same(oElement), "Deleted from deep create");
 
 		// code under test
-		oPromise = oCache._delete(oGroupLock, undefined, "SO_2_SOITEM/-1", null, fnCallback);
+		oPromise = oCache._delete(oGroupLock, undefined, "SO_2_SOITEM/1", null, fnCallback);
 
 		assert.strictEqual(oPromise.getResult(), undefined);
 		assert.deepEqual(aPostBodyCollection, ["~a~", "~c~"]);
@@ -952,7 +932,7 @@ sap.ui.define([
 	//*********************************************************************************************
 	QUnit.test("_Cache#removeElement for a created kept-alive context inside", function (assert) {
 		var oCache = new _Cache(this.oRequestor, "EMPLOYEES"),
-			aCacheData = [{
+			aElements = [{
 				"@$ui5._" : {predicate : "('2')"},
 				"@odata.etag" : "before"
 			}, {
@@ -961,42 +941,86 @@ sap.ui.define([
 			}, {
 				"@odata.etag" : "after"
 			}],
-			oElement = aCacheData[1],
+			oElement = aElements[1],
 			iIndex;
 
-		aCacheData.$byPredicate = {
+		aElements.$byPredicate = {
 			"($uid=id-1-23)" : oElement,
 			"('1')" : oElement,
-			"('2')" : aCacheData[0]
+			"('2')" : aElements[0]
 		};
-		aCacheData.$count = 42;
-		aCacheData.$created = 23;
+		aElements.$count = 42;
+		aElements.$created = 23;
 		oCache.iActiveElements = 19;
+		oCache.aElements = aElements;
 		oCache.iLimit = 42;
 		this.mock(_Cache).expects("getElementIndex")
-			.withExactArgs(sinon.match.same(aCacheData), "('1')", 2).returns(1);
+			.withExactArgs(sinon.match.same(aElements), "('1')", 2).returns(1);
 		this.mock(_Helper).expects("addToCount")
 			.withExactArgs(sinon.match.same(oCache.mChangeListeners), "",
-				sinon.match.same(aCacheData), -1);
+				sinon.match.same(aElements), -1);
 		this.mock(oCache).expects("adjustIndexes")
-			.withExactArgs("", sinon.match.same(aCacheData), 1, -1);
+			.withExactArgs("", sinon.match.same(aElements), 1, -1);
 
 		// code under test
-		iIndex = oCache.removeElement(aCacheData, 2, "('1')", "");
+		iIndex = oCache.removeElement(undefined, 2, "('1')", "");
 
 		assert.strictEqual(iIndex, 1);
-		assert.strictEqual(aCacheData.$created, 22);
+		assert.strictEqual(aElements.$created, 22);
 		assert.strictEqual(oCache.iActiveElements, 18);
 		assert.strictEqual(oCache.iLimit, 42);
-		assert.deepEqual(aCacheData, [{
+		assert.deepEqual(aElements, [{
 			"@$ui5._" : {predicate : "('2')"},
 			"@odata.etag" : "before"
 		}, {
 			"@odata.etag" : "after"
 		}]);
-		assert.deepEqual(aCacheData.$byPredicate, {"('2')" : aCacheData[0]});
+		assert.deepEqual(aElements.$byPredicate, {"('2')" : aElements[0]});
 	});
 
+	//*********************************************************************************************
+["", "~path~"].forEach(function (sPath) {
+	[false, true].forEach(function (bTransient) {
+		[false, true].forEach(function (bDefault) {
+			const sTitle = `_Cache#restoreElement, path=${sPath}, transient=${bTransient},
+ default=${bDefault}`;
+
+	QUnit.test(sTitle, function (assert) {
+		const oCache = new _Cache(this.oRequestor, "TEAMS");
+		oCache.iLimit = 234;
+		oCache.iActiveElements = 1;
+		const aElements = [];
+		aElements.$byPredicate = {};
+		aElements.$created = 2;
+		if (bDefault) {
+			oCache.aElements = aElements;
+		}
+		this.mock(oCache).expects("adjustIndexes")
+			.withExactArgs(sPath, sinon.match.same(aElements), 42, 1, "~iDeletedIndex~");
+		const oHelperMock = this.mock(_Helper);
+		oHelperMock.expects("getPrivateAnnotation")
+			.withExactArgs("~oElement~", "transientPredicate")
+			.returns(bTransient ? "($uid=id-1-23)" : undefined);
+		oHelperMock.expects("addToCount")
+			.withExactArgs(sinon.match.same(oCache.mChangeListeners), sPath,
+				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~");
+
+		assert.strictEqual(oCache.iLimit, bTransient || sPath ? 234 : 235);
+		assert.strictEqual(aElements.$created, bTransient ? 3 : 2);
+		assert.strictEqual(oCache.iActiveElements, bTransient && !sPath ? 2 : 1);
+		assert.deepEqual(aElements.$byPredicate, {"~predicate~" : "~oElement~"});
+	});
+		});
+	});
+});
+
 	//*********************************************************************************************
 	QUnit.test("_Cache#registerChangeListener", function () {
 		var oCache = new _Cache(this.oRequestor, "TEAMS");
@@ -2762,7 +2786,6 @@ sap.ui.define([
 			fnPatchSent = function () {},
 			oRequestCall,
 			oRequestLock = {unlock : function () {}},
-			mTypeForMetaPath = {},
 			oUpdatePromise,
 			that = this;
 
@@ -2772,7 +2795,7 @@ sap.ui.define([
 			.withExactArgs(sinon.match.same(_GroupLock.$cached), sEntityPath)
 			.returns(SyncPromise.resolve(oEntity));
 		oCacheMock.expects("fetchTypes").withExactArgs()
-			.returns(SyncPromise.resolve(mTypeForMetaPath));
+			.returns(SyncPromise.resolve({}));
 		oHelperMock.expects("makeUpdateData")
 			.withExactArgs(["Address", "City"], "Walldorf")
 			.returns("~oUpdateData~");
@@ -3067,6 +3090,20 @@ sap.ui.define([
 		});
 	});
 
+	//*********************************************************************************************
+	QUnit.test("Cache#getTypes", function (assert) {
+		var oCache = new _Cache(this.oRequestor, "TEAMS('42')/Foo"),
+			oSyncPromise = {
+				getResult : mustBeMocked
+			};
+
+		this.mock(oCache).expects("fetchTypes").withExactArgs().returns(oSyncPromise);
+		this.mock(oSyncPromise).expects("getResult").withExactArgs().returns("~mTypeForMetaPath~");
+
+		// code under test
+		assert.strictEqual(oCache.getTypes(), "~mTypeForMetaPath~");
+	});
+
 	//*********************************************************************************************
 	QUnit.test("Cache#visitResponse: key predicates: ignore simple values", function () {
 		var oCache = new _Cache(this.oRequestor, "TEAMS('42')/Foo"),
@@ -4658,8 +4695,7 @@ sap.ui.define([
 			oCache.mLateQueryOptions = {};
 		}
 		oHelperMock.expects("getMetaPath").withExactArgs("").returns("~resMetaPath~");
-		this.mock(oCache).expects("fetchTypes")
-			.withExactArgs().returns(SyncPromise.resolve(mTypeForMetaPath));
+		this.mock(oCache).expects("getTypes").withExactArgs().returns(mTypeForMetaPath);
 		oHelperMock.expects("buildPath").withExactArgs(oCache.sMetaPath, "~resMetaPath~")
 			.returns("~metaPath~");
 		oHelperMock.expects("getQueryOptionsForPath")
@@ -4759,8 +4795,7 @@ sap.ui.define([
 		oCache.mLateQueryOptions = {};
 		oHelperMock.expects("getMetaPath").withExactArgs("('31')/entity/path")
 			.returns("entity/path");
-		this.mock(oCache).expects("fetchTypes")
-			.withExactArgs().returns(SyncPromise.resolve(mTypeForMetaPath));
+		this.mock(oCache).expects("getTypes").withExactArgs().returns(mTypeForMetaPath);
 		oHelperMock.expects("getQueryOptionsForPath")
 			.withExactArgs(sinon.match.same(oCache.mLateQueryOptions), "('31')/entity/path")
 			.returns(mQueryOptionsForPath);
@@ -4882,8 +4917,7 @@ sap.ui.define([
 		oCache.mLateQueryOptions = {};
 		oHelperMock.expects("getMetaPath").withExactArgs("('1')/entity/path")
 			.returns("entity/path");
-		this.mock(oCache).expects("fetchTypes")
-			.withExactArgs().returns(SyncPromise.resolve(mTypeForMetaPath));
+		this.mock(oCache).expects("getTypes").withExactArgs().returns(mTypeForMetaPath);
 		oHelperMock.expects("buildPath").withExactArgs(oCache.sMetaPath, "entity/path")
 			.returns(oCache.sMetaPath + "/entity/path");
 		oHelperMock.expects("getQueryOptionsForPath")
@@ -4980,8 +5014,7 @@ sap.ui.define([
 			};
 
 		oCache.mLateQueryOptions = {};
-		this.mock(oCache).expects("fetchTypes").twice()
-			.withExactArgs().returns(SyncPromise.resolve(mTypeForMetaPath));
+		this.mock(oCache).expects("getTypes").twice().withExactArgs().returns(mTypeForMetaPath);
 		oHelperMock.expects("getQueryOptionsForPath").twice()
 			.withExactArgs(sinon.match.same(oCache.mLateQueryOptions), "")
 			.returns(mQueryOptionsForPath);
@@ -5056,7 +5089,7 @@ sap.ui.define([
 		oCache.fetchValue = function () {};
 
 		oCache.mLateQueryOptions = {};
-		this.mock(oCache).expects("fetchTypes").withExactArgs().returns(SyncPromise.resolve({}));
+		this.mock(oCache).expects("getTypes").withExactArgs().returns({});
 		this.mock(_Helper).expects("getQueryOptionsForPath")
 			.withExactArgs(sinon.match.same(oCache.mLateQueryOptions), "")
 			.returns(mQueryOptionsForPath);
@@ -5135,8 +5168,7 @@ sap.ui.define([
 			$expand : {expand : {}},
 			$select : ["select"]
 		};
-		this.mock(oCache).expects("fetchTypes").withExactArgs()
-			.returns(SyncPromise.resolve(mTypeForMetaPath));
+		this.mock(oCache).expects("getTypes").withExactArgs().returns(mTypeForMetaPath);
 		this.mock(_Helper).expects("getQueryOptionsForPath")
 			.withExactArgs(sinon.match.same(oCache.mLateQueryOptions), "")
 			.returns(mQueryOptionsForPath);
@@ -5181,6 +5213,7 @@ sap.ui.define([
 	QUnit.test("Cache#fetchLateProperty: no late properties", function (assert) {
 		var oCache = new _Cache(this.oRequestor, "Employees");
 
+		this.mock(oCache).expects("getTypes").withExactArgs().returns({});
 		this.mock(_Helper).expects("intersectQueryOptions").never();
 		this.oRequestorMock.expects("request").never();
 		this.mock(_Helper).expects("updateSelected").never();
@@ -5198,6 +5231,7 @@ sap.ui.define([
 		var oCache = new _Cache(this.oRequestor, "Employees");
 
 		oCache.mLateQueryOptions = {};
+		this.mock(oCache).expects("getTypes").withExactArgs().returns({});
 		this.mock(_Helper).expects("intersectQueryOptions").never();
 		this.oRequestorMock.expects("request").never();
 		this.mock(_Helper).expects("updateSelected").never();
@@ -5216,6 +5250,7 @@ sap.ui.define([
 			mQueryOptionsForPath = {};
 
 		oCache.mLateQueryOptions = {};
+		this.mock(oCache).expects("getTypes").withExactArgs().returns({});
 		this.mock(_Helper).expects("getMetaPath").withExactArgs("('1')").returns("");
 		this.mock(_Helper).expects("getQueryOptionsForPath")
 			.withExactArgs(sinon.match.same(oCache.mLateQueryOptions), "('1')")
@@ -5605,6 +5640,13 @@ sap.ui.define([
 			"insert a created entity at the end: only non-created entities move");
 	});
 
+	//*********************************************************************************************
+	QUnit.test("Cache#adjustIndexes: no path and no aReadRequests", function () {
+		const oCache = new _Cache(this.oRequestor, "Employees"); // would be an _AggregationCache
+
+		oCache.adjustIndexes("", [], 1);
+	});
+
 	//*********************************************************************************************
 [false, true].forEach(function (bSharedRequest) {
 	QUnit.test("CollectionCache: bSharedRequest = " + bSharedRequest, function (assert) {
@@ -5760,22 +5802,67 @@ sap.ui.define([
 	});
 
 	//*********************************************************************************************
-	QUnit.test("Cache#getAndRemoveValue", function (assert) {
-		var oCache = new _Cache(this.oRequestor, "SalesOrders('1')"),
-			oParent = {
-				value : "~value~"
-			};
+[false, true].forEach(function (bTransferable) {
+	QUnit.test(`Cache#getAndRemoveCollection: transferable=${bTransferable}`, function (assert) {
+		const oCache = new _Cache(this.oRequestor, "SalesOrders('1')");
+			oCache.fetchValue = function () {};
+		const aCollection = [];
+		if (bTransferable) {
+			aCollection.$transfer = true;
+		}
+		const oParent = {
+			collection : aCollection
+		};
 
-		oCache.fetchValue = function () {};
 		this.mock(oCache).expects("fetchValue")
 			.withExactArgs(sinon.match.same(_GroupLock.$cached), "path/to")
 			.returns(SyncPromise.resolve(oParent));
 		this.mock(oCache).expects("checkSharedRequest").withExactArgs();
 
 		// code under test
-		assert.strictEqual(oCache.getAndRemoveValue("path/to/value"), "~value~");
+		assert.strictEqual(oCache.getAndRemoveCollection("path/to/collection"),
+			bTransferable ? aCollection : undefined);
+
+		if (bTransferable) {
+			assert.notOk("collection" in oParent);
+		} else {
+			assert.strictEqual(oParent.collection, aCollection);
+		}
+		assert.notOk("$transfer" in aCollection);
+	});
+});
+
+	//*********************************************************************************************
+	QUnit.test("Cache#getAndRemoveCollection: empty", function (assert) {
+		const oCache = new _Cache(this.oRequestor, "SalesOrders('1')");
+		oCache.fetchValue = function () {};
+
+		this.mock(oCache).expects("fetchValue")
+			.withExactArgs(sinon.match.same(_GroupLock.$cached), "path/to")
+			.returns(SyncPromise.resolve({}));
+		this.mock(oCache).expects("checkSharedRequest").withExactArgs();
 
-		assert.notOk("value" in oParent);
+		// code under test
+		assert.strictEqual(oCache.getAndRemoveCollection("path/to/collection"), undefined);
+	});
+
+	//*********************************************************************************************
+	QUnit.test("Cache#getAndRemoveCollection: not a collection", function (assert) {
+		const oCache = new _Cache(this.oRequestor, "SalesOrders('1')");
+		oCache.fetchValue = function () {};
+		const oParent = {
+			value : "foo"
+		};
+
+		this.mock(oCache).expects("fetchValue")
+			.withExactArgs(sinon.match.same(_GroupLock.$cached), "path/to")
+			.returns(SyncPromise.resolve(oParent));
+		this.mock(oCache).expects("checkSharedRequest").withExactArgs();
+
+		assert.throws(function () {
+			// code under test
+			oCache.getAndRemoveCollection("path/to/value");
+		}, new Error("path/to/value must point to a collection"));
 	});
 
 	//*********************************************************************************************
@@ -6628,6 +6715,8 @@ sap.ui.define([
 	QUnit.test("CollectionCache#getExclusiveFilter: no created entities", function (assert) {
 		var oCache = this.createCache("Employees");
 
+		this.mock(oCache).expects("getTypes").never();
+
 		// code under test
 		assert.strictEqual(oCache.getExclusiveFilter(), undefined);
 	});
@@ -6653,8 +6742,7 @@ sap.ui.define([
 			oHelperMock = this.mock(_Helper),
 			mTypeForMetaPath = {};
 
-		this.mock(oCache).expects("fetchTypes")
-			.returns(SyncPromise.resolve(mTypeForMetaPath));
+		this.mock(oCache).expects("getTypes").returns(mTypeForMetaPath);
 		oCache.aElements.$created = 0;
 		if (oFixture.single || oFixture.multiple) {
 			oCache.aElements.unshift(oElement0);
@@ -7389,8 +7477,8 @@ sap.ui.define([
 	});
 
 	//*********************************************************************************************
-[false, true].forEach(function (bError) {
-	QUnit.test("CollectionCache#requestElements: error=" + bError, function (assert) {
+[false, true, undefined].forEach(function (bSuccess) { // undefined -> obsolete
+	QUnit.test("CollectionCache#requestElements: success=" + bSuccess, function (assert) {
 		var oCache = this.createCache("Employees"),
 			oCacheMock = this.mock(oCache),
 			oCheckRangeExpectation,
@@ -7400,15 +7488,15 @@ sap.ui.define([
 			iStart = 0,
 			oFetchPromise = Promise.resolve("~mTypes~"),
 			oHandleResponseExpectation,
+			oPromise,
 			oResetExpectation, // avoid "was used before it was defined"
 			oRequestPromise = Promise.resolve().then(function () {
 				oCheckRangeExpectation = oCacheMock.expects("checkRange")
-					.withExactArgs(sinon.match(function (oPromise) {
-							return oPromise === oFillExpectation.args[0][0];
-						}), iStart, iEnd);
-				if (bError) {
-					oResetExpectation = oCacheMock.expects("fill")
-						.withExactArgs(undefined, iStart, iEnd);
+					.exactly(bSuccess !== undefined ? 1 : 0)
+					.withExactArgs(sinon.match.same(oPromise), iStart, iEnd);
+				oResetExpectation = oCacheMock.expects("fill").exactly(bSuccess === false ? 1 : 0)
+					.withExactArgs(undefined, iStart, iEnd);
+				if (bSuccess === false) {
 					throw oError;
 				}
 				return "~oResult~";
@@ -7423,33 +7511,36 @@ sap.ui.define([
 				/*oPayload*/undefined, "~fnDataRequested~")
 			.returns(oRequestPromise);
 		oCacheMock.expects("fetchTypes").withExactArgs().returns(oFetchPromise);
-		oHandleResponseExpectation = oCacheMock.expects("handleResponse").exactly(bError ? 0 : 1)
+		oHandleResponseExpectation = oCacheMock.expects("handleResponse").exactly(bSuccess ? 1 : 0)
 			.withExactArgs("~oResult~", iStart, "~mTypes~")
 			.returns("~iFiltered~");
-		oCacheMock.expects("handleCount").exactly(bError ? 0 : 1)
+		oCacheMock.expects("handleCount").exactly(bSuccess ? 1 : 0)
 			.withExactArgs("~oGroupLock~", 0, iStart, iEnd, "~oResult~", "~iFiltered~");
 		oFillExpectation = oCacheMock.expects("fill")
 			.withExactArgs(sinon.match.instanceOf(SyncPromise), iStart, iEnd);
 
 		// code under test
-		oCache.requestElements(iStart, iEnd, "~oGroupLock~", 0, "~fnDataRequested~");
+		oPromise = oCache.requestElements(iStart, iEnd, "~oGroupLock~", 0, "~fnDataRequested~");
 
+		assert.deepEqual(oCache.aReadRequests, [{iStart, iEnd}]);
+		if (bSuccess === undefined) {
+			oCache.aReadRequests[0].obsolete = true;
+		}
 		assert.strictEqual(oCache.bSentRequest, true);
+		assert.strictEqual(oFillExpectation.args[0][0], oPromise);
 
-		return Promise.all([
-			oFetchPromise,
-			oRequestPromise.catch(function () {})
-		]).then(function () {
-			var oPromise = oFillExpectation.args[0][0];
-
-			return oPromise.then(function () {
-				assert.notOk(bError);
-				assert.ok(oCheckRangeExpectation.calledBefore(oHandleResponseExpectation));
-			}, function (oRequestError) {
-				assert.ok(bError);
+		return oPromise.then(function () {
+			assert.ok(bSuccess);
+			assert.ok(oCheckRangeExpectation.calledBefore(oHandleResponseExpectation));
+		}, function (oRequestError) {
+			assert.notOk(bSuccess);
+			if (bSuccess === false) {
 				assert.strictEqual(oRequestError, oError);
 				assert.ok(oCheckRangeExpectation.calledBefore(oResetExpectation));
-			});
+			} else {
+				assert.ok(oRequestError.canceled);
+				assert.strictEqual(oRequestError.message, "Request is obsolete");
+			}
 		});
 	});
 });
@@ -8037,6 +8128,7 @@ sap.ui.define([
 	QUnit.test("CollectionCache#read: $count & create, bInactive=" + bInactive, function (assert) {
 		var sResourcePath = "Employees",
 			oCache = this.createCache(sResourcePath),
+			fnCancelCallback = sinon.spy(),
 			iCountAfterCreate = bInactive ? 26 : 27,
 			oCountChangeListener = {onChange : function () {}},
 			oCountChangeListenerMock = this.mock(oCountChangeListener),
@@ -8069,7 +8161,8 @@ sap.ui.define([
 				oCache.registerChangeListener("$count", oCountChangeListener);
 
 				return oCache.create(oGroupLock, SyncPromise.resolve("Employees"), "",
-					sTransientPredicate, {}, null, false, function fnSubmitCallback() {});
+					sTransientPredicate, {}, false, null, function fnSubmitCallback() {},
+					fnCancelCallback);
 			})
 			.then(function () {
 				var oReadGroupLock = {
@@ -8086,8 +8179,14 @@ sap.ui.define([
 				assert.strictEqual(oCache.iActiveElements, bInactive ? 0 : 1);
 
 				oCountChangeListenerMock.expects("onChange").exactly(bInactive ? 0 : 1)
-					.withExactArgs(26, undefined);
-				that.mock(oGroupLock).expects("cancel").withExactArgs();
+					.withExactArgs(26, undefined)
+					.callsFake(function () {
+						assert.strictEqual(fnCancelCallback.callCount, 0, "not yet");
+					});
+				that.mock(oGroupLock).expects("cancel").withExactArgs()
+					.callsFake(function () {
+						assert.strictEqual(fnCancelCallback.callCount, 1);
+					});
 
 				// code under test - cancel the create
 				oPostRequest.args[0][6]();
@@ -8552,7 +8651,7 @@ sap.ui.define([
 
 		// code under test
 		oCache._delete(null, "TEAMS('0')/TEAM_2_EMPLOYEES",
-			sPathInCache + "/-1", //TODO sPathInCache + sTransientPredicate
+			sPathInCache + "/1", //TODO sPathInCache + sTransientPredicate
 			null, false, fnDeleteCallback);
 
 		assert.strictEqual(aCollection.$count, 41);
@@ -8973,7 +9072,7 @@ sap.ui.define([
 						"No 'update' allowed while waiting for server response",
 						oError.message);
 				});
-			oCache._delete(oDeleteGroupLock, "n/a", /*TODO sTransientPredicate*/"-1")
+			oCache._delete(oDeleteGroupLock, "n/a", /*TODO sTransientPredicate*/"0")
 				.then(function () {
 					assert.ok(false, "unexpected success - _delete");
 				}, function (oError) {
@@ -9182,6 +9281,9 @@ sap.ui.define([
 				that.oRequestorMock.expects("relocate")
 					.withExactArgs(sParkedGroupId, sinon.match.same(oPostBody), sUpdateGroupId);
 
+				if (oFixture.createGroupId === "$inactive.$auto") {
+					oCache.setInactive(sTransientPredicate, false); // activate
+				}
 				// code under test - first update -> relocate
 				aPromises.push(oCache.update(oGroupLock1, "Name", "John Doe", that.spy(), "n/a",
 					sTransientPredicate));
@@ -9202,15 +9304,9 @@ sap.ui.define([
 	//*********************************************************************************************
 	//TODO move to _Cache!
 [false, true].forEach(function (bInactive) {
-	[false, true].forEach(function (bStayInactive) {
-		[false, true].forEach(function (bAtEndOfCreated) {
-			var sTitle = "CollectionCache: create entity without initial data, bInactive="
-				+ bInactive + ", bStayInactive= " + bStayInactive + ", bAtEndOfCreated="
-				+ bAtEndOfCreated;
-
-			if (!bInactive && bStayInactive) {
-				return;
-			}
+	[false, true].forEach(function (bAtEndOfCreated) {
+		var sTitle = "CollectionCache: create entity without initial data, bInactive="
+			+ bInactive + ", bAtEndOfCreated=" + bAtEndOfCreated;
 
 	QUnit.test(sTitle, function (assert) {
 		var oCache = _Cache.create(this.oRequestor, "Employees"),
@@ -9277,27 +9373,13 @@ sap.ui.define([
 		}
 
 		this.mock(oUpdateGroupLock).expects("getGroupId").withExactArgs().returns("updateGroup");
-		oHelperMock.expects("updateAll").exactly(bStayInactive ? 1 : 0)
-			.withExactArgs(sinon.match.same(oCache.mChangeListeners), sTransientPredicate,
-				sinon.match.same(oCache.aElements[bAtEndOfCreated ? 1 : 0]),
-				{"@$ui5.context.isInactive" : 1}).callThrough();
-		this.oRequestorMock.expects("relocate").exactly(bInactive && !bStayInactive ? 1 : 0)
-			.withExactArgs("$inactive.updateGroup",
-				sinon.match.same(oCache.aElements[bAtEndOfCreated ? 1 : 0]["@$ui5._"].postBody),
-				"updateGroup");
 		oHelperMock.expects("updateAll")
 			.withExactArgs({}, sTransientPredicate, sinon.match.object, {Name : "foo"});
-		this.mock(oCountChangeListener).expects("onChange")
-			.exactly(bInactive && !bStayInactive ? 1 : 0)
-			.withExactArgs(43, undefined);
 		oCache.registerChangeListener("$count", oCountChangeListener);
 		oHelperMock.expects("updateAll")
 			.withExactArgs(sinon.match.same(oCache.mChangeListeners), sTransientPredicate,
-				sinon.match.same(oCache.aElements[bAtEndOfCreated ? 1 : 0]),
-					bInactive && !bStayInactive
-						? {Name : "foo", "@$ui5.context.isInactive" : false}
-						: {Name : "foo"}
-				).callThrough();
+				sinon.match.same(oCache.aElements[bAtEndOfCreated ? 1 : 0]), {Name : "foo"})
+			.callThrough();
 		oHelperMock.expects("updateSelected")
 			.withExactArgs(sinon.match.same(oCache.mChangeListeners), sTransientPredicate,
 				sinon.match.same(oCache.aElements[bAtEndOfCreated ? 1 : 0]),
@@ -9310,29 +9392,20 @@ sap.ui.define([
 		this.mock(oUpdateGroupLock).expects("unlock").withExactArgs();
 
 		// code under test
-		oCache.update(oUpdateGroupLock, "Name", "foo", this.spy(), undefined, sTransientPredicate,
-			undefined, undefined, undefined, undefined, bStayInactive);
+		oCache.update(oUpdateGroupLock, "Name", "foo", this.spy(), undefined, sTransientPredicate);
 
 		assert.strictEqual(oCache.aElements[bAtEndOfCreated ? 1 : 0]["@$ui5._"].transient,
-			bStayInactive ? "$inactive.updateGroup" : "updateGroup");
-
-		if (bInactive) {
-			assert.strictEqual(
-				_Helper.hasPrivateAnnotation(oCache.aElements[bAtEndOfCreated ? 1 : 0],
-					"initialData"), bStayInactive);
-			assert.strictEqual(
-				oCache.aElements[bAtEndOfCreated ? 1 : 0]["@$ui5.context.isInactive"],
-				bStayInactive ? 1 : false, "isInactive");
-			assert.strictEqual(oCache.iActiveElements, bStayInactive ? 0 : 1);
-		} else {
-			assert.strictEqual(
-				oCache.aElements[bAtEndOfCreated ? 1 : 0]["@$ui5.context.isInactive"], undefined);
-			assert.strictEqual(oCache.iActiveElements, 1);
-		}
+			bInactive ? "$inactive.updateGroup" : "updateGroup");
+		assert.strictEqual(
+			_Helper.hasPrivateAnnotation(oCache.aElements[bAtEndOfCreated ? 1 : 0],
+				"initialData"), bInactive);
+		assert.strictEqual(
+			oCache.aElements[bAtEndOfCreated ? 1 : 0]["@$ui5.context.isInactive"],
+			bInactive ? true : undefined, "isInactive");
+		assert.strictEqual(oCache.iActiveElements, bInactive ? 0 : 1);
 
 		return oPromise;
 	});
-		});
 	});
 });
 
@@ -9644,7 +9717,7 @@ sap.ui.define([
 
 		// code under test
 		oDeletePromise = oCache._delete(null, "n/a",
-			/*TODO sTransientPredicate*/"-1", null, false, function () {
+			/*TODO sTransientPredicate*/"0", null, false, function () {
 				throw new Error();
 			});
 
@@ -9727,7 +9800,7 @@ sap.ui.define([
 				.returns(Promise.resolve());
 
 			// code under test
-			return oCache._delete(oDeleteGroupLock, sEditUrl, /*TODO sTransientPredicate*/"-1",
+			return oCache._delete(oDeleteGroupLock, sEditUrl, /*TODO sTransientPredicate*/"0",
 					null, fnCallback)
 				.then(function () {
 					sinon.assert.calledOnceWithExactly(fnCallback, 0, -1);
@@ -9931,8 +10004,7 @@ sap.ui.define([
 					oCacheMock.expects("keepOnlyGivenElements").exactly(bSingle ? 0 : 1)
 						.withExactArgs(aPredicates).callThrough(); // too hard to refactor :-(
 					// Note: fetchTypes() would have been triggered by read() already
-					oCacheMock.expects("fetchTypes").withExactArgs()
-						.returns(SyncPromise.resolve(mTypeForMetaPath));
+					oCacheMock.expects("getTypes").withExactArgs().returns(mTypeForMetaPath);
 					oCache.beforeUpdateSelected = function () {};
 					for (i = 0; i < iReceivedLength; i += 1) { // prepare request/response
 						sPredicate = "('" + oFixture.aValues[i].key + "')";
@@ -10052,7 +10124,6 @@ sap.ui.define([
 			oPromise,
 			mQueryOptions = {},
 			sResourcePath = "TEAMS('42')/Foo",
-			mTypeForMetaPath = {},
 			oCache = this.createCache(sResourcePath);
 
 		// cache preparation
@@ -10061,8 +10132,7 @@ sap.ui.define([
 		oCache.aElements.$byPredicate = mByPredicate;
 		oCache.mLateQueryOptions = mLateQueryOptions;
 
-		this.mock(oCache).expects("fetchTypes").withExactArgs()
-			.returns(SyncPromise.resolve(mTypeForMetaPath));
+		this.mock(oCache).expects("getTypes").withExactArgs().returns({});
 		this.mock(Object).expects("assign")
 			.withExactArgs({}, sinon.match.same(oCache.mQueryOptions),
 				sinon.match.same(oCache.mLateQueryOptions))
@@ -10101,10 +10171,7 @@ sap.ui.define([
 		// Note: fill cache with more than just "visible" rows
 		return this.mockRequestAndRead(oCache, 0, sResourcePath, 0, 4, 4, undefined, "26")
 			.then(function () {
-				var mTypeForMetaPath = {};
-
-				that.mock(oCache).expects("fetchTypes").withExactArgs()
-					.returns(SyncPromise.resolve(mTypeForMetaPath));
+				that.mock(oCache).expects("getTypes").withExactArgs().returns({});
 				that.mock(_Helper).expects("intersectQueryOptions").returns({/*don't care*/});
 				that.mock(oCache).expects("keepOnlyGivenElements").withExactArgs([])
 					.returns([]);
@@ -10176,8 +10243,7 @@ sap.ui.define([
 				oCache.aElements[2].Bar = {
 					"@$ui5._" : {predicate : "(2)"}
 				};
-				that.mock(oCache).expects("fetchTypes").withExactArgs()
-					.returns(SyncPromise.resolve(mTypeForMetaPath));
+				that.mock(oCache).expects("getTypes").withExactArgs().returns(mTypeForMetaPath);
 				that.mock(Object).expects("assign")
 					.withExactArgs({}, sinon.match.same(oCache.mQueryOptions),
 						sinon.match.same(oCache.mLateQueryOptions))
@@ -10251,8 +10317,7 @@ sap.ui.define([
 					var mTypeForMetaPath = {};
 
 					oCache.aElements[0] = undefined; // can result from a failed requestElements
-					oCacheMock.expects("fetchTypes").withExactArgs()
-						.returns(SyncPromise.resolve(mTypeForMetaPath));
+					oCacheMock.expects("getTypes").withExactArgs().returns(mTypeForMetaPath);
 					that.mock(Object).expects("assign")
 						.withExactArgs({}, sinon.match.same(oCache.mQueryOptions),
 							sinon.match.same(oCache.mLateQueryOptions))
@@ -10331,8 +10396,7 @@ sap.ui.define([
 			oCache.aElements.push(oElement);
 			oCache.aElements.$byPredicate["('c')"] = oElement;
 
-			this.mock(oCache).expects("fetchTypes").withExactArgs()
-				.returns(SyncPromise.resolve(mTypeForMetaPath));
+			this.mock(oCache).expects("getTypes").withExactArgs().returns(mTypeForMetaPath);
 			this.mock(oCache).expects("checkSharedRequest").withExactArgs();
 			this.mock(Object).expects("assign")
 				.withExactArgs({}, sinon.match.same(oCache.mQueryOptions),
@@ -10650,15 +10714,26 @@ sap.ui.define([
 		oCache.mChangeListeners = mChangeListeners;
 		oCache.sContext = "~context~";
 		oCache.aElements.$count = oCache.iLimit = 3;
+		oCache.aReadRequests = [{iStart : 1, iEnd : 2}, {iStart : 3, iEnd : 4}];
 
 		oSetQueryOptionsExpectation = this.mock(oCache).expects("setQueryOptions")
 			.withExactArgs("~mQueryOptions~", true);
 		oFireChangeExpectation = this.mock(_Helper).expects("fireChange")
-			.withExactArgs({"" : "~listeners~"}, "");
+			.withExactArgs({"" : "~listeners~"}, "")
+			.callsFake(function () {
+				assert.deepEqual(oCache.aReadRequests, [
+					{iStart : 1, iEnd : 2, obsolete : true},
+					{iStart : 3, iEnd : 4, obsolete : true}
+				]);
+			});
 
 		// code under test
 		oCache.reset([], undefined, "~mQueryOptions~");
 
+		assert.deepEqual(oCache.aReadRequests, [
+			{iStart : 1, iEnd : 2, obsolete : true},
+			{iStart : 3, iEnd : 4, obsolete : true}
+		]);
 		assert.strictEqual(oCache.aElements, aElements);
 		assert.strictEqual(oCache.aElements.length, 0);
 		assert.strictEqual(oCache.aElements.$created, 0);
@@ -10685,6 +10760,40 @@ sap.ui.define([
 		assert.strictEqual(oCache.isDeletingInOtherGroup("group"), true);
 	});
 
+	//*********************************************************************************************
+[false, 1].forEach(function (bInactive) {
+	QUnit.test(`CollectionCache#setInactive(${bInactive})`, function (assert) {
+		const iActivateCount = bInactive ? 0 : 1;
+		const oCache = this.createCache("Employees");
+		oCache.iActiveElements = 42;
+		this.mock(oCache).expects("getValue").withExactArgs("($uid=id-1-23)").returns("~oElement~");
+		this.mock(_Helper).expects("updateAll")
+			.withExactArgs(sinon.match.same(oCache.mChangeListeners), "($uid=id-1-23)",
+				"~oElement~", {"@$ui5.context.isInactive" : bInactive});
+		this.mock(_Helper).expects("deletePrivateAnnotation").exactly(iActivateCount)
+			.withExactArgs("~oElement~", "initialData");
+		this.mock(_Helper).expects("addToCount").exactly(iActivateCount)
+			.withExactArgs(sinon.match.same(oCache.mChangeListeners), "",
+				sinon.match.same(oCache.aElements), 1);
+
+		// code under test
+		oCache.setInactive("($uid=id-1-23)", bInactive);
+
+		assert.strictEqual(oCache.iActiveElements, bInactive ? 42 : 43);
+	});
+});
+
+	//*********************************************************************************************
+	QUnit.test("CollectionCache#setEmpty", function (assert) {
+		const oCache = this.createCache("Employees");
+
+		// code under test
+		oCache.setEmpty();
+
+		assert.strictEqual(oCache.aElements.$count, 0);
+		assert.strictEqual(oCache.iLimit, 0);
+	});
+
 	//*********************************************************************************************
 	QUnit.test("SingleCache", function (assert) {
 		var oCache,
@@ -12453,15 +12562,23 @@ sap.ui.define([
 	});
 
 	//*********************************************************************************************
-	QUnit.test("CollectionCache#drop", function (assert) {
-		var oCache = this.createCache("Employees");
-
+[undefined, "($uid=id-1-23)"].forEach((sTransientPredicate) => {
+	QUnit.test(`CollectionCache#drop, ${sTransientPredicate}`, function (assert) {
+		const oCache = this.createCache("Employees");
 		oCache.aElements[23] = "~b~";
 		oCache.aElements.$byPredicate = {
 			"('a')" : "~a~",
 			"('b')" : "~b~",
 			"('c')" : "~c~"
 		};
+		oCache.aElements.$created = 7;
+		oCache.iActiveElements = 5;
+		oCache.iLimit = 42;
+		if (sTransientPredicate) {
+			oCache.aElements.$byPredicate[sTransientPredicate] = "~b~";
+		}
+		this.mock(_Helper).expects("getPrivateAnnotation")
+			.withExactArgs("~b~", "transientPredicate").returns(sTransientPredicate);
 
 		// code under test
 		oCache.drop(23, "('b')");
@@ -12472,6 +12589,22 @@ sap.ui.define([
 			"('a')" : "~a~",
 			"('c')" : "~c~"
 		});
+		assert.strictEqual(oCache.aElements.$created, sTransientPredicate ? 6 : 7);
+		assert.strictEqual(oCache.iActiveElements, sTransientPredicate ? 4 : 5);
+		assert.strictEqual(oCache.iLimit, sTransientPredicate ? 43 : 42);
+	});
+});
+
+	//*********************************************************************************************
+	QUnit.test("CollectionCache#drop: Must not drop a transient element", function (assert) {
+		const oCache = this.createCache("Employees");
+		oCache.aElements[23] = {"@$ui5.context.isTransient" : true};
+		this.mock(_Helper).expects("getPrivateAnnotation").never();
+
+		assert.throws(function () {
+			// code under test
+			oCache.drop(23, "n/a");
+		}, new Error("Must not drop a transient element"));
 	});
 
 	//*********************************************************************************************
@@ -12789,7 +12922,7 @@ sap.ui.define([
 
 		// refreshKeptElements
 		oCacheMock.expects("checkSharedRequest").withExactArgs();
-		oCacheMock.expects("fetchTypes").returns(SyncPromise.resolve(mTypes));
+		oCacheMock.expects("getTypes").returns(mTypes);
 		this.mock(this.oRequestor).expects("request")
 			.withExactArgs("GET", "Employees?$filter=" + oFixture.sFilter,
 				sinon.match.same(oGroupLock))
@@ -12833,6 +12966,7 @@ sap.ui.define([
 	QUnit.test("refreshKeptElements w/o kept-alive element", function (assert) {
 		var oCache = _Cache.create(this.oRequestor, "Employees", {});
 
+		this.mock(oCache).expects("getTypes").never();
 		this.mock(oCache).expects("checkSharedRequest").withExactArgs();
 		this.mock(oCache.oRequestor).expects("request").never();