@openui5/sap.ui.core 1.119.0 → 1.120.0

package/test/sap/ui/core/qunit/odata/v2/ODataModelNoFakeService.qunit.js

@@ -1603,7 +1603,8 @@ sap.ui.define([
 });
 
 	//*********************************************************************************************
-	QUnit.test("_processSuccess: _updateChangedEntity is called correctly", function (assert) {
+[204, "204", 205, "205"].forEach(function (vStatusCode, i){
+	QUnit.test("_processSuccess: _updateChangedEntity is called correctly, #" + i, function (assert) {
 		var mEntityTypes = {},
 			oModel = {
 				oMetadata : {
@@ -1626,7 +1627,7 @@ sap.ui.define([
 				key : "key",
 				requestUri : "/service/path"
 			},
-			oResponse = {statusCode : 204};
+			oResponse = {statusCode : vStatusCode};
 
 		oModelMock.expects("_normalizePath").withExactArgs("/path").returns("normalizedPath");
 		this.mock(oModel.oMetadata).expects("_getEntityTypeByPath")
@@ -1657,6 +1658,7 @@ sap.ui.define([
 			/*fnSuccess*/ undefined, /*mGetEntities*/ {}, /*mChangeEntities*/ {}, mEntityTypes,
 			/*bBatch*/ false, "aRequests");
 	});
+});
 
 	//*********************************************************************************************
 [{
@@ -6829,7 +6831,7 @@ sap.ui.define([
 				.withExactArgs("~oAbortedError");
 		}
 		oModelMock.expects("getMessagesByEntity")
-			.withExactArgs("~sKey", !bDeleteEntity)
+			.withExactArgs("~sKey", true)
 			.returns("~aMessages");
 		oMessagingMock.expects("removeMessages").withExactArgs("~aMessages");
 
@@ -6886,7 +6888,7 @@ sap.ui.define([
 			.withExactArgs(sinon.match.same(oContext));
 		this.mock(oModel).expects("_removeEntity").withExactArgs("~sKey");
 		this.mock(oModel).expects("getMessagesByEntity")
-			.withExactArgs("~sKey", false)
+			.withExactArgs("~sKey", true)
 			.returns("~aMessages");
 		this.mock(Messaging).expects("removeMessages")
 			.withExactArgs("~aMessages");

package/test/sap/ui/core/qunit/odata/v2/ODataPropertyBindingNoFakeService.qunit.js

@@ -128,13 +128,13 @@ sap.ui.define([
 
 	//*********************************************************************************************
 [
-	{aControlMessages : [], bForceUpdate : false, bSameContext : true},
-	{aControlMessages : [], bForceUpdate : false, bSameContext : false},
-	{aControlMessages : [{}], bForceUpdate : true, bSameContext : false}
+	{aMessages : [], bForceUpdate : false, bSameContext : true},
+	{aMessages : [], bForceUpdate : false, bSameContext : false},
+	{aMessages : [{}], bForceUpdate : true, bSameContext : false}
 ].forEach(function (oFixture) {
 	var sTitle = "setContext: changed context (relative binding)"
 			+ "; same context = " + oFixture.bSameContext
-			+ "; number of control messages = " + oFixture.aControlMessages.length;
+			+ "; number of messages = " + oFixture.aMessages.length;
 
 	QUnit.test(sTitle, function (assert) {
 		var oContext = {
@@ -147,7 +147,7 @@ sap.ui.define([
 				isRelative : function () {}
 			},
 			oDataState = {
-				getControlMessages : function () {}
+				getMessages : function () {}
 			};
 
 		this.mock(oContext).expects("isPreliminary").withExactArgs().returns(false);
@@ -157,8 +157,7 @@ sap.ui.define([
 		this.mock(oBinding).expects("isRelative").withExactArgs().returns(true);
 		if (!oFixture.bSameContext) {
 			this.mock(oBinding).expects("getDataState").withExactArgs().returns(oDataState);
-			this.mock(oDataState).expects("getControlMessages").withExactArgs()
-				.returns(oFixture.aControlMessages);
+			this.mock(oDataState).expects("getMessages").withExactArgs().returns(oFixture.aMessages);
 		}
 
 		this.mock(oBinding).expects("checkUpdate").withExactArgs(oFixture.bForceUpdate);

package/test/sap/ui/core/qunit/odata/v2/ODataTreeBindingFlatNoFakeService.qunit.js

@@ -1631,6 +1631,7 @@ sap.ui.define([
 					"hierarchy-node-for" : "~nodeKey",
 					"hierarchy-preorder-rank-for" : "~preorderRank"
 				},
+				_getHeaders() {},
 				_updateNodeInfoAfterSave : function () {},
 				getNumberOfExpandedLevels : function () {},
 				getResolvedPath : function () {}
@@ -1664,6 +1665,7 @@ sap.ui.define([
 				.and(sinon.match.has("select",
 					"~key0,~key1,~nodeKey,~descendantCount,~drillState,~preorderRank")))
 			.returns("~URLParameters");
+		this.mock(oBinding).expects("_getHeaders").withExactArgs().returns("~headers");
 		this.mock(oModel).expects("read")
 			.withExactArgs("~resolvedPath", {
 				error : "~fnError",
@@ -1678,6 +1680,7 @@ sap.ui.define([
 						and : true})
 				],
 				groupId : "~groupID",
+				headers : "~headers",
 				sorters : "~aSorters",
 				success : sinon.match.func,
 				urlParameters : "~URLParameters"
@@ -1721,6 +1724,7 @@ sap.ui.define([
 					"hierarchy-node-for" : "~nodeKey",
 					"hierarchy-preorder-rank-for" : "~preorderRank"
 				},
+				_getHeaders() {},
 				_updateNodeInfoAfterSave : function () {},
 				getNumberOfExpandedLevels : function () {},
 				getResolvedPath : function () {}
@@ -1747,6 +1751,7 @@ sap.ui.define([
 				.and(sinon.match.has("select",
 					"~key0,~key1,~nodeKey,~descendantCount,~drillState,~preorderRank")))
 			.returns("~URLParameters");
+		this.mock(oBinding).expects("_getHeaders").withExactArgs().returns("~headers");
 		this.mock(oModel).expects("read")
 			.withExactArgs("~resolvedPath", {
 				error : undefined,
@@ -1760,6 +1765,7 @@ sap.ui.define([
 						and : true})
 				],
 				groupId : "~groupID",
+				headers : "~headers",
 				sorters : [],
 				success : sinon.match.func,
 				urlParameters : "~URLParameters"
@@ -1826,4 +1832,212 @@ sap.ui.define([
 		// code under test
 		assert.strictEqual(ODataTreeBindingFlat.prototype._calcIndexDelta.call(oBinding, 5), 1);
 	});
-});
+
+	//*********************************************************************************************
+	QUnit.test("_requestServerIndexNodes: calls _getHeaders", function (assert) {
+		const oBinding = {
+			_aPendingRequests: [],
+			oModel: {
+				read() {}
+			},
+			oTreeProperties: {
+				"hierarchy-level-for": "~hierarchy-level-for"
+			},
+			_getHeaders() {},
+			getNumberOfExpandedLevels() {},
+			getResolvedPath() {}
+		};
+		const oBindingMock = this.mock(oBinding);
+		oBindingMock.expects("getNumberOfExpandedLevels").withExactArgs().returns(13);
+		oBindingMock.expects("getResolvedPath").withExactArgs().returns("~sAbsolutePath");
+		oBindingMock.expects("_getHeaders").withExactArgs().returns("~headers");
+		const oReadExpectation = this.mock(oBinding.oModel).expects("read")
+			.withExactArgs("~sAbsolutePath", {
+				error: sinon.match.func,
+				filters: [new Filter({filters: [new Filter("~hierarchy-level-for", "LE", 13)], and: true})],
+				groupId: undefined, // not relevant for this test
+				headers: "~headers",
+				sorters: [],
+				success: sinon.match.func,
+				urlParameters: ["$skip=3", "$top=142", "$inlinecount=allpages"]
+			})
+			.returns("~oReadHandle");
+
+		// code under test
+		const oResultPromise = ODataTreeBindingFlat.prototype._requestServerIndexNodes.call(oBinding, 3, 42, 100);
+
+		assert.deepEqual(oBinding._aPendingRequests,
+			[{oRequestHandle: "~oReadHandle", iSkip: 3, iTop: 142, iThreshold: 100}]);
+		assert.ok(oResultPromise instanceof Promise);
+
+		// code under test
+		oReadExpectation.args[0][1].success("~oData");
+
+		return oResultPromise.then((oResult) => {
+			assert.deepEqual(oResult, {oData: "~oData", iSkip: 3, iTop: 142});
+			assert.deepEqual(oBinding._aPendingRequests, []);
+		});
+	});
+
+	//*********************************************************************************************
+	QUnit.test("_requestChildren: calls _getHeaders", function (assert) {
+		const oBinding = {
+			_aPendingChildrenRequests: [],
+			oModel: {
+				read() {}
+			},
+			oTreeProperties: {
+				"hierarchy-node-for": "~hierarchy-node-for",
+				"hierarchy-parent-node-for": "~hierarchy-parent-node-for"
+			},
+			_getHeaders() {},
+			getResolvedPath() {}
+		};
+		const oParentNode = {
+			key: "~parentNodeKey",
+			context: {
+				getProperty() {}
+			}
+		};
+		this.mock(oParentNode.context).expects("getProperty")
+			.withExactArgs("~hierarchy-node-for")
+			.returns("~sHierarchyNodeValue");
+		this.mock(oBinding).expects("getResolvedPath").withExactArgs().returns("~sAbsolutePath");
+		this.mock(oBinding).expects("_getHeaders").withExactArgs().returns("~headers");
+		const oReadExpectation = this.mock(oBinding.oModel).expects("read")
+			.withExactArgs("~sAbsolutePath", {
+				error: sinon.match.func,
+				filters: [
+					new Filter({
+						filters: [new Filter("~hierarchy-parent-node-for", "EQ", "~sHierarchyNodeValue")],
+						and: true
+					})],
+				groupId: undefined, // not relevant for this test
+				headers: "~headers",
+				sorters: [],
+				success: sinon.match.func,
+				urlParameters: ["$skip=~skip", "$top=~top", "$inlinecount=allpages"]
+			})
+			.returns("~oReadHandle");
+
+		// code under test
+		const oResultPromise = ODataTreeBindingFlat.prototype._requestChildren.call(oBinding, oParentNode,
+			"~skip", "~top");
+
+		assert.deepEqual(oBinding._aPendingChildrenRequests,
+			[{sParent: "~parentNodeKey", oRequestHandle: "~oReadHandle", iSkip: "~skip", iTop: "~top"}]);
+		assert.ok(oResultPromise instanceof Promise);
+
+		// code under test
+		oReadExpectation.args[0][1].success("~oData");
+
+		return oResultPromise.then((oResult) => {
+			assert.deepEqual(oResult, {oData: "~oData", iSkip: "~skip", iTop: "~top"});
+			assert.deepEqual(oBinding._aPendingChildrenRequests, []);
+		});
+	});
+
+	//*********************************************************************************************
+	QUnit.test("_requestSubTree: calls _getHeaders", function (assert) {
+		const oBinding = {
+			_aPendingSubtreeRequests: [],
+			oModel: {
+				read() {}
+			},
+			oTreeProperties: {
+				"hierarchy-level-for": "~hierarchy-level-for",
+				"hierarchy-node-for": "~hierarchy-node-for"
+			},
+			_getHeaders() {},
+			getResolvedPath() {}
+		};
+		const oParentNode = {
+			key: "~parentNodeKey",
+			context: {
+				getProperty() {}
+			}
+		};
+		this.mock(oParentNode.context).expects("getProperty")
+			.withExactArgs("~hierarchy-node-for")
+			.returns("~sHierarchyNodeForProperty");
+		this.mock(oBinding).expects("getResolvedPath").withExactArgs().returns("~sAbsolutePath");
+		const oExpectedNodeFilter = new Filter("~hierarchy-node-for", "EQ", "~sHierarchyNodeForProperty");
+		const oExpectedLevelFilter = new Filter("~hierarchy-level-for", "LE", "~iLevel");
+		this.mock(oBinding).expects("_getHeaders").withExactArgs().returns("~headers");
+		const oReadExpectation = this.mock(oBinding.oModel).expects("read")
+			.withExactArgs("~sAbsolutePath", {
+				error: sinon.match.func,
+				filters: [new Filter({filters: [oExpectedNodeFilter, oExpectedLevelFilter], and: true})],
+				groupId: undefined, // not relevant for this test
+				headers: "~headers",
+				sorters: [],
+				success: sinon.match.func,
+				urlParameters: []
+			})
+			.returns("~oReadHandle");
+
+		// code under test
+		const oResultPromise = ODataTreeBindingFlat.prototype._requestSubTree.call(oBinding, oParentNode, "~iLevel");
+
+		assert.deepEqual(oBinding._aPendingSubtreeRequests,
+			[{sParent: "~parentNodeKey", iLevel: "~iLevel", oRequestHandle: "~oReadHandle"}]);
+		assert.ok(oResultPromise instanceof Promise);
+
+		// code under test
+		oReadExpectation.args[0][1].success("~oData");
+
+		return oResultPromise.then((oResult) => {
+			assert.deepEqual(oResult, {oData: "~oData", iLevel: "~iLevel", sParent: "~parentNodeKey"});
+			assert.deepEqual(oBinding._aPendingSubtreeRequests, []);
+		});
+	});
+
+	//*********************************************************************************************
+	QUnit.test("_generateSiblingsPositionRequest: calls _getHeaders", function (assert) {
+		const oBinding = {
+			oModel: {
+				createCustomParams() {},
+				read() {}
+			},
+			mParameters: {foo: "~bar"},
+			oTreeProperties: {
+				"hierarchy-sibling-rank-for": "~hierarchy-sibling-rank-for"
+			},
+			_getHeaders() {}
+		};
+		const oNode = {
+			context: {
+				getPath() {}
+			}
+		};
+		this.mock(oNode.context).expects("getPath").withExactArgs().returns("~sAbsolutePath");
+		this.mock(oBinding.oModel).expects("createCustomParams")
+			.withExactArgs(sinon.match((oParams) => {
+				assert.notStrictEqual(oParams, oBinding.mParameters);
+				assert.deepEqual(oParams, {
+					foo: "~bar",
+					select: "~hierarchy-sibling-rank-for"
+				});
+				return true;
+			}))
+			.returns("~mCustomParams");
+		this.mock(oBinding).expects("_getHeaders").withExactArgs().returns("~headers");
+		this.mock(oBinding.oModel).expects("read")
+			.withExactArgs("~sAbsolutePath", {
+				error: "~error",
+				groupId: "~groupId",
+				headers: "~headers",
+				success: "~success",
+				urlParameters: "~mCustomParams"
+			})
+			.returns("~oReadHandle");
+		const mParameters = {
+			error: "~error",
+			groupId: "~groupId",
+			success: "~success"
+		};
+
+		// code under test
+		ODataTreeBindingFlat.prototype._generateSiblingsPositionRequest.call(oBinding, oNode, mParameters);
+	});
+});

package/test/sap/ui/core/qunit/odata/v2/ODataTreeBindingNoFakeService.qunit.js

@@ -42,6 +42,7 @@ sap.ui.define([
 				operationMode : OperationMode.Client,
 				rootLevel : 23,
 				threshold : 77,
+				transitionMessagesOnly : "truthy",
 				usePreliminaryContext : "bUsePreliminaryContext",
 				useServersideApplicationFilters : "bUseServersideApplicationFilters"
 			},
@@ -92,9 +93,9 @@ sap.ui.define([
 		assert.strictEqual(oBinding.bUseServersideApplicationFilters,
 			"bUseServersideApplicationFilters");
 		assert.strictEqual(oBinding.bUsePreliminaryContext, "bUsePreliminaryContext");
+		assert.strictEqual(oBinding.bTransitionMessagesOnly, true);
 	});
 
-
 	//*********************************************************************************************
 	QUnit.test("constructor: with single Filter object", function (assert) {
 		var oApplicationFilter = new Filter("propertyPath", "GE", "foo"),
@@ -168,6 +169,7 @@ sap.ui.define([
 		assert.strictEqual(oBinding.iThreshold, 0);
 		assert.strictEqual(oBinding.bUseServersideApplicationFilters, false);
 		assert.strictEqual(oBinding.bUsePreliminaryContext, "bPreliminaryContext");
+		assert.strictEqual(oBinding.bTransitionMessagesOnly, false);
 
 		oModelMock.expects("checkFilterOperation").withExactArgs([]);
 
@@ -543,10 +545,12 @@ sap.ui.define([
 		var oBinding = {
 				oModel : {read : function () {}},
 				mRequestHandles : {},
+				_getHeaders() {},
 				getResolvedPath : function () {}
 			};
 
 		this.mock(oBinding).expects("getResolvedPath").withExactArgs().returns("~resolvedPath");
+		this.mock(oBinding).expects("_getHeaders").withExactArgs().returns("~headers");
 		this.mock(oBinding.oModel).expects("read")
 			.withExactArgs("~resolvedPath", sinon.match.object.and(sinon.match.has("groupId"))
 				.and(sinon.match.has("success")).and(sinon.match.has("error")))
@@ -733,6 +737,7 @@ sap.ui.define([
 			oBinding = {
 				sGroupId : "~sGroupId",
 				oModel : oModel,
+				_getHeaders() {},
 				_getNavPath : function () {},
 				_processODataObject : function () {},
 				getPath : function () {},
@@ -745,8 +750,9 @@ sap.ui.define([
 			};
 
 		this.mock(oBinding).expects("getResolvedPath").withExactArgs().returns("~resolvedPath");
+		this.mock(oBinding).expects("_getHeaders").withExactArgs().returns("~headers");
 		oExpectation = this.mock(oModel).expects("read").withExactArgs("~resolvedPath", {
-			error : sinon.match.func, groupId : "~sGroupId", success : sinon.match.func
+			error : sinon.match.func, groupId : "~sGroupId", headers : "~headers", success : sinon.match.func
 		}).returns("~readHandle");
 
 		// code under test
@@ -783,6 +789,7 @@ sap.ui.define([
 				oModel : oModel,
 				oRootContext : "~oldRootContext",
 				mRequestHandles : {},
+				_getHeaders() {},
 				fireDataReceived : function () {},
 				getResolvedPath : function () {}
 			},
@@ -790,8 +797,9 @@ sap.ui.define([
 			oExpectation;
 
 		this.mock(oBinding).expects("getResolvedPath").withExactArgs().returns("~resolvedPath");
+		this.mock(oBinding).expects("_getHeaders").withExactArgs().returns("~headers");
 		oExpectation = this.mock(oModel).expects("read").withExactArgs("~resolvedPath", {
-			error : sinon.match.func, groupId : "~sGroupId", success : sinon.match.func
+			error : sinon.match.func, groupId : "~sGroupId", headers : "~headers", success : sinon.match.func
 		}).returns("~readHandle");
 
 		// code under test
@@ -1098,13 +1106,16 @@ sap.ui.define([
 				bSkipDataEvents : true,
 				aSorters : "~sorters",
 				iTotalCollectionCount : "~count",
+				_getHeaders() {},
 				getResolvedPath : function () {}
 			},
 			aUrlParams = ["~custom"];
 
 		this.mock(oBinding).expects("getResolvedPath").withExactArgs().returns("~resolvedPath");
+		this.mock(oBinding).expects("_getHeaders").withExactArgs().returns("~headers");
 		this.mock(oBinding.oModel).expects("read")
 			.withExactArgs("~resolvedPath", {
+				headers : "~headers",
 				urlParameters : sinon.match.same(aUrlParams)
 					.and(sinon.match(["~custom", "$top=~count"])),
 				success : sinon.match.func,
@@ -1130,13 +1141,16 @@ sap.ui.define([
 				bSkipDataEvents : true,
 				aSorters : "~sorters",
 				iTotalCollectionCount : vTotalCollectionCount,
+				_getHeaders() {},
 				getResolvedPath : function () {}
 			},
 			aUrlParams = ["~custom"];
 
 		this.mock(oBinding).expects("getResolvedPath").withExactArgs().returns("~resolvedPath");
+		this.mock(oBinding).expects("_getHeaders").withExactArgs().returns("~headers");
 		this.mock(oBinding.oModel).expects("read")
 			.withExactArgs("~resolvedPath", {
+				headers : "~headers",
 				urlParameters : sinon.match.same(aUrlParams)
 					.and(sinon.match(["~custom"])),
 				success : sinon.match.func,
@@ -1252,4 +1266,181 @@ sap.ui.define([
 		assert.deepEqual(oBinding.getFilterInfo(), null);
 		assert.deepEqual(oBinding.aApplicationFilters, []);
 	});
+
+	//*********************************************************************************************
+	QUnit.test("_loadSubTree: success case", function (assert) {
+		var oLoadSubTreePromise, oReadExpectation,
+			oBinding = {
+				bHasTreeAnnotations: true,
+				oModel: {
+					callAfterUpdate: function () {},
+					getKey: function () {},
+					read: function () {}
+				},
+				mRequestHandles: {},
+				bSkipDataEvents: true,
+				aSorters: "~aSorters",
+				_createKeyMap: function () {},
+				_getHeaders() {},
+				_importCompleteKeysHierarchy: function () {},
+				_updateNodeKey: function () {},
+				getResolvedPath: function () {}
+			},
+			oBindingMock = this.mock(oBinding),
+			oData = {results: ["~oData"]},
+			oModelMock = this.mock(oBinding.oModel),
+			aParams = ["~sTreeBindingParams"];
+
+		oBindingMock.expects("getResolvedPath").withExactArgs().returns("~sAbsolutePath");
+		oBindingMock.expects("_getHeaders").withExactArgs().returns("~headers");
+		oReadExpectation = oModelMock.expects("read")
+			.withExactArgs("~sAbsolutePath", {
+				error: sinon.match.func,
+				groupId: undefined,
+				headers: "~headers",
+				sorters: "~aSorters",
+				success: sinon.match.func,
+				urlParameters: sinon.match.same(aParams)
+			})
+			.returns("~oReadHandle");
+
+		// code under test
+		oLoadSubTreePromise = ODataTreeBinding.prototype._loadSubTree.call(oBinding, "~oNode", aParams);
+
+		assert.deepEqual(oBinding.mRequestHandles, {"loadSubTree-~sTreeBindingParams": "~oReadHandle"});
+
+		oModelMock.expects("getKey").withExactArgs("~oData").returns("~sParentKey");
+		oBindingMock.expects("_updateNodeKey").withExactArgs("~oNode", "~sParentKey");
+		oBindingMock.expects("_createKeyMap").withExactArgs(sinon.match.same(oData.results), true).returns("~mKeys");
+		oBindingMock.expects("_importCompleteKeysHierarchy").withExactArgs("~mKeys");
+		oModelMock.expects("callAfterUpdate").withExactArgs(sinon.match.func);
+
+		// code under test
+		oReadExpectation.args[0][1].success(oData);
+
+		assert.deepEqual(oBinding.mRequestHandles, {});
+		assert.deepEqual(oBinding.bNeedsUpdate, true);
+
+		return oLoadSubTreePromise.then(function (oData0) {
+			assert.strictEqual(oData0, oData);
+		});
+	});
+
+	//*********************************************************************************************
+	QUnit.test("_loadSubNodes: calls _getHeaders", function (assert) {
+		const oBinding = {
+			oFinalLengths: {"~sNodeId": 5},
+			oModel: {
+				read() {}
+			},
+			mRequestHandles: {},
+			bSkipDataEvents: true,
+			_getHeaders() {}
+		};
+		this.mock(oBinding).expects("_getHeaders").withExactArgs().returns("~headers");
+		this.mock(oBinding.oModel).expects("read")
+			.withExactArgs("~sNodeId", {
+				error: sinon.match.func,
+				groupId: undefined, // not relevant for this test
+				headers: "~headers",
+				sorters: undefined, // not relevant for this test
+				success: sinon.match.func,
+				urlParameters: "~aParams"
+			})
+			.returns("~oReadHandle");
+
+		// code under test - start index, length and threshold are not relevant for this use case
+		ODataTreeBinding.prototype._loadSubNodes.call(oBinding, "~sNodeId", /*iStartIndex*/undefined,
+			/*iLength*/undefined, /*iThreshold*/undefined, "~aParams");
+
+		assert.strictEqual(oBinding.bSkipDataEvents, false);
+		assert.deepEqual(oBinding.mRequestHandles, {"~sNodeId-undefined-undefined-undefined": "~oReadHandle"});
+	});
+	/** @deprecated As of version 1.120.0, reason OperationMode.Auto */
+	QUnit.test("_getCountForCollection: calls _getHeaders", function () {
+		const oBinding = {
+			sCountMode: CountMode.Inline,
+			bHasTreeAnnotations: true,
+			oModel: {
+				read() {}
+			},
+			sOperationMode: OperationMode.Auto,
+			_getHeaders() {},
+			getResolvedPath() {}
+		};
+		this.mock(oBinding).expects("getResolvedPath").withExactArgs().returns("~sAbsolutePath");
+		this.mock(oBinding).expects("_getHeaders").withExactArgs().returns("~headers");
+		this.mock(oBinding.oModel).expects("read")
+			.withExactArgs("~sAbsolutePath", {
+				error: sinon.match.func,
+				groupId: undefined, // not relevant for this test
+				headers: "~headers",
+				success: sinon.match.func,
+				urlParameters: ["$top=0", "$inlinecount=allpages"]
+			});
+
+		// code under test
+		ODataTreeBinding.prototype._getCountForCollection.call(oBinding);
+	});
+	/** @deprecated As of version 1.120.0, reason OperationMode.Auto */
+	QUnit.test("_getCountForCollection: don't call _getHeaders for $count request", function () {
+		const oBinding = {
+			sCountMode: CountMode.Request,
+			bHasTreeAnnotations: true,
+			oModel: {
+				read() {}
+			},
+			sOperationMode: OperationMode.Auto,
+			getResolvedPath() {}
+		};
+		this.mock(oBinding).expects("getResolvedPath").withExactArgs().returns("~sAbsolutePath");
+		this.mock(oBinding.oModel).expects("read")
+			.withExactArgs("~sAbsolutePath/$count", {
+				error: sinon.match.func,
+				groupId: undefined, // not relevant for this test
+				headers: undefined,
+				success: sinon.match.func,
+				urlParameters: []
+			});
+
+		// code under test
+		ODataTreeBinding.prototype._getCountForCollection.call(oBinding);
+	});
+
+	//*********************************************************************************************
+	QUnit.test("_getCountForNodeId: don't call _getHeaders for $count request", function () {
+		const oBinding = {
+			oModel: {
+				read() {}
+			},
+			getFilterParams() {}
+		};
+		this.mock(oBinding).expects("getFilterParams").withExactArgs().returns(undefined);
+		this.mock(oBinding.oModel).expects("read")
+			.withExactArgs("~sNodeId/$count", {
+				error: sinon.match.func,
+				groupId: undefined, // not relevant for this test
+				sorters: undefined, // not relevant for this test
+				success: sinon.match.func,
+				urlParameters: []
+			});
+
+		// code under test
+		ODataTreeBinding.prototype._getCountForNodeId.call(oBinding, "~sNodeId");
+	});
+
+	//*********************************************************************************************
+[
+	{bTransitionMessagesOnly: true, result: {"sap-messages": "transientOnly"}},
+	{bTransitionMessagesOnly: false, result: undefined}
+].forEach((oFixture) => {
+	QUnit.test("_getHeaders: bTransitionMessagesOnly=" + oFixture.bTransitionMessagesOnly, function (assert) {
+		const oBinding = {
+			bTransitionMessagesOnly: oFixture.bTransitionMessagesOnly
+		};
+
+		// code under test
+		assert.deepEqual(ODataTreeBinding.prototype._getHeaders.call(oBinding), oFixture.result);
+	});
+});
 });

package/test/sap/ui/core/qunit/odata/v2/V2ODataModelDataState.qunit.js

@@ -15,9 +15,10 @@ sap.ui.define([
 	"sap/ui/model/DataState",
 	"sap/ui/model/json/JSONModel",
 	"sap/ui/model/odata/v2/ODataModel",
+	"sap/ui/model/type/Currency",
 	"sap/ui/model/type/Float"
 ], function(deepEqual, deepExtend, Button, Input, Text, Configuration, library, Messaging, ControlMessageProcessor,
-		Message, MockServer, VerticalLayout, DataState, JSONModel, ODataModel, Float) {
+		Message, MockServer, VerticalLayout, DataState, JSONModel, ODataModel, Currency, Float) {
 	"use strict";
 
 	// shortcut for sap.ui.core.MessageType
@@ -1565,7 +1566,7 @@ sap.ui.define([
 					{ path: "/ProductSet('AD-1000')/Price" },
 					{ path: "/ProductSet('AD-1000')/CurrencyCode" }
 				],
-				type: 'sap.ui.model.type.Currency'
+				type: Currency.getMetadata().getName()
 			}
 		});
 		//let the message manager control the vertical layout for messages