@openui5/sap.ui.core 1.118.0 → 1.119.0

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

@@ -187,8 +187,8 @@ sap.ui.define([
 		this.mock(ODataModel.prototype).expects("_createMetadataUrl")
 			.withExactArgs("/$metadata")
 			.returns("~metadataUrl");
-		oDataModelMock.expects("_getSharedData").withExactArgs("server", "~serverUrl").returns(undefined);
-		oDataModelMock.expects("_getSharedData").withExactArgs("service", "~serviceUrl").returns(undefined);
+		oDataModelMock.expects("_getSharedData").withExactArgs("server", "~serverUrl").returns({});
+		oDataModelMock.expects("_getSharedData").withExactArgs("service", "~serviceUrl").returns({});
 		oDataModelMock.expects("_getSharedData").withExactArgs("meta", "~metadataUrl").returns(oMetadata);
 		this.mock(ODataModel.prototype).expects("_cacheSupported").withExactArgs("~metadataUrl").returns(false);
 		this.mock(ODataModel.prototype).expects("_getAnnotationCacheKey")
@@ -216,6 +216,77 @@ sap.ui.define([
 	});
 });
 
+	//*********************************************************************************************
+[{
+	parameter : undefined, // value for tokenHandling c'tor parameter
+	member : true, // expected value for bTokenHandling member of model instance
+	headerIsSet : true // whether the x-csrf-token request header is expected to be set
+}, {
+	parameter : false,
+	member : false,
+	headerIsSet : false
+}, {
+	parameter : "skipServerCache",
+	member : true,
+	headerIsSet : false
+}].forEach((oFixture) => {
+	QUnit.test("constructor: tokenHandling=" + oFixture.parameter, function (assert) {
+		const mParameters = {
+				serviceUrl : "~serviceUrl",
+				tokenHandling : oFixture.parameter
+			};
+		this.mock(ODataModel.prototype).expects("createCodeListModelParameters")
+			.withExactArgs(sinon.match.same(mParameters))
+			.returns("~codeListModelParameters");
+		this.mock(ODataModel.prototype).expects("setDeferredGroups").withExactArgs(["changes"]);
+		this.mock(ODataModel.prototype).expects("setChangeGroups").withExactArgs({"*":{groupId: "changes"}});
+		this.mock(ODataModel.prototype).expects("setHeaders").withExactArgs(undefined)
+			.callThrough(/*initializes this.mCustomHeaders*/);
+		this.mock(ODataModel.prototype).expects("_getServerUrl")
+		    .exactly(oFixture.parameter === "skipServerCache" ? 0 : 1)
+			.withExactArgs()
+			.returns("~serverUrl");
+		this.mock(ODataModel.prototype).expects("_createMetadataUrl")
+			.withExactArgs("/$metadata")
+			.returns("~metadataUrl");
+		const oDataModelMock = this.mock(ODataModel);
+		const oServerCache = {securityToken : "~token"};
+		oDataModelMock.expects("_getSharedData")
+			.exactly(oFixture.parameter === "skipServerCache" ? 0 : 1)
+			.withExactArgs("server", "~serverUrl")
+			.returns(oServerCache);
+		oDataModelMock.expects("_getSharedData").withExactArgs("service", "~serviceUrl").returns({});
+		const oMetadata = {
+			oMetadata : {
+				isLoaded : function () {},
+				loaded : function () {}
+			}
+		};
+		oDataModelMock.expects("_getSharedData").withExactArgs("meta", "~metadataUrl").returns(oMetadata);
+		this.mock(ODataModel.prototype).expects("_cacheSupported").withExactArgs("~metadataUrl").returns(false);
+		this.mock(ODataModel.prototype).expects("_getAnnotationCacheKey")
+			.withExactArgs("~metadataUrl")
+			.returns(undefined);
+		// called in ODataModel#constructor and ODataAnnotations#constructor
+		const oPromise = Promise.resolve("~metadata");
+		this.mock(oMetadata.oMetadata).expects("loaded").withExactArgs().exactly(3).returns(oPromise);
+		this.mock(oMetadata.oMetadata).expects("isLoaded").withExactArgs().returns(true);
+		this.mock(ODataModel.prototype).expects("_initializeMetadata").withExactArgs();
+		this.mock(ODataAnnotations.prototype).expects("addSource")
+			.withExactArgs([{type : "xml", data : sinon.match.instanceOf(Promise)}]);
+		this.mock(Configuration).expects("getLanguageTag").withExactArgs().returns("~languageTag");
+
+		// code under test
+		const oModel = new ODataModel(mParameters);
+
+		assert.strictEqual(oModel.bTokenHandling, oFixture.member);
+		assert.deepEqual(oModel.oSharedServerData, oFixture.parameter === "skipServerCache" ? undefined : oServerCache);
+		assert.strictEqual(oModel.oHeaders["x-csrf-token"], oFixture.headerIsSet ? "~token" : undefined);
+
+		return oPromise;
+	});
+});
+
 	//*********************************************************************************************
 	QUnit.test("_read: updateAggregatedMessages and bSideEffects are passed to _createRequest",
 			function (assert) {
@@ -6309,6 +6380,54 @@ sap.ui.define([
 		assert.strictEqual(oModel.bTokenHandling, false);
 	});
 
+	//*********************************************************************************************
+	QUnit.test("refreshSecurityToken: no server cache for tokenHandling='skipServerCache'", function (assert) {
+		const oModel = {
+				bDisableHeadRequestForToken : true,
+				_createRequest() {},
+				_createRequestUrlWithNormalizedPath() {},
+				_getHeader() {},
+				_getHeaders() {},
+				_request() {},
+				_setSessionContextIdHeader() {},
+				getServiceMetadata() {},
+				oHeaders : {},
+				oSharedServiceData : {}
+			};
+		const oModelMock = this.mock(oModel);
+		const oRequest = {headers : {}};
+		const oResponse = {headers : "~responseHdrs"};
+
+		oModelMock.expects("_createRequestUrlWithNormalizedPath").withExactArgs("/").returns("~sUrl");
+		oModelMock.expects("_getHeaders").withExactArgs(undefined, true).returns("~headers");
+		oModelMock.expects("_createRequest")
+			.withExactArgs("~sUrl", "", "GET", "~headers", null, null, false)
+			.returns(oRequest);
+		oModelMock.expects("getServiceMetadata").withExactArgs().returns("~serviceMetadata");
+		const oRequestCall = oModelMock.expects("_request")
+			.withExactArgs(sinon.match.same(oRequest), sinon.match.func, sinon.match.func, undefined, undefined,
+				"~serviceMetadata")
+			.returns("~requestHandle");
+
+		// code under test - parameters fnSuccess, fnError and bAsync are not relevant for this test
+		const oResult = ODataModel.prototype.refreshSecurityToken.call(oModel);
+
+		assert.strictEqual(oResult.request, "~requestHandle");
+
+		oModelMock.expects("_getHeader").withExactArgs("x-csrf-token", "~responseHdrs").returns("~token");
+		oModelMock.expects("_getHeader").withExactArgs("sap-contextid", "~responseHdrs").returns("~contextId");
+		oModelMock.expects("_setSessionContextIdHeader").withExactArgs("~contextId");
+
+		// code under test - call success handler handleSuccess
+		oRequestCall.args[0][1]("~oData", oResponse);
+
+		assert.strictEqual(oModel.oSharedServiceData.securityToken, "~token");
+		assert.strictEqual(oModel.oHeaders["x-csrf-token"], "~token");
+		return oModel.pSecurityToken.then((sToken) => {
+			assert.strictEqual(sToken, "~token");
+		});
+	});
+
 	//*********************************************************************************************
 	QUnit.test("getContext", function (assert) {
 		var oContext, oContext1,

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

@@ -86,12 +86,37 @@ sap.ui.define([
 			});
 		assert.ok(bCreatedPromisePending, "Created Promise still pending");
 
+		assert.throws(function () {
+			// code under test
+			oContext.setCreatedPersisted();
+		}, new Error("Already 'created', currently transient: true"));
+
 		fnResolve("bar");
 		return oCreatedPromise.then(function () {
 			assert.strictEqual(bCreatedPromisePending, false, "Created Promise resolved");
 		});
 	});
 
+	//*********************************************************************************************
+	QUnit.test("setCreatedPersisted", function (assert) {
+		const oContext = Context.create({/*oModel*/}, {/*oBinding*/}, "/foo", 42);
+
+		// code under test
+		oContext.setCreatedPersisted();
+
+		assert.strictEqual(oContext.isTransient(), false);
+		assert.ok(oContext.created() instanceof Promise);
+
+		assert.throws(function () {
+			// code under test
+			oContext.setCreatedPersisted();
+		}, new Error("Already 'created', currently transient: false"));
+
+		return oContext.created().then(function (vResult) {
+			assert.strictEqual(vResult, undefined);
+		});
+	});
+
 	//*********************************************************************************************
 	QUnit.test("getGeneration: after Context.createNewContext", function (assert) {
 		var oBinding = {},
@@ -1986,7 +2011,67 @@ sap.ui.define([
 	});
 
 	//*********************************************************************************************
-	QUnit.test("patch", function () {
+	QUnit.test("move", function (assert) {
+		const oBinding = {
+			move : mustBeMocked
+		};
+		const oContext = Context.create({/*oModel*/}, oBinding, "/EMPLOYEES('42')");
+		let bResolved = false;
+		this.mock(oBinding).expects("move").withExactArgs(sinon.match.same(oContext), "~oParent~")
+			.returns(new SyncPromise(function (resolve) {
+				setTimeout(function () {
+					bResolved = true;
+					resolve(); // Note: without a defined result
+				}, 0);
+			}));
+
+		// code under test
+		const oPromise = oContext.move({parent : "~oParent~"});
+
+		assert.ok(oPromise instanceof Promise);
+		return oPromise.then(function () {
+			assert.ok(bResolved, "not too soon");
+		});
+	});
+
+	//*********************************************************************************************
+	QUnit.test("move: fails", function (assert) {
+		const oBinding = {
+			move : mustBeMocked
+		};
+		const oContext = Context.create({/*oModel*/}, oBinding, "/EMPLOYEES('42')");
+
+		assert.throws(function () {
+			// code under test
+			oContext.move({});
+		}, new Error("Unsupported parent context: undefined"));
+
+		assert.throws(function () {
+			// code under test
+			oContext.move({parent : null});
+		}, new Error("Unsupported parent context: null"));
+
+		assert.throws(function () {
+			// code under test
+			oContext.move({parent : oContext});
+		}, new Error("Unsupported parent context: " + oContext));
+
+		this.mock(oBinding).expects("move").withExactArgs(sinon.match.same(oContext), "~oParent~")
+			.returns(SyncPromise.reject("~error~"));
+
+		// code under test
+		const oPromise = oContext.move({parent : "~oParent~"});
+
+		assert.ok(oPromise instanceof Promise);
+		return oPromise.then(function () {
+			assert.ok(false, "unexpected success");
+		}, function (vError) {
+			assert.strictEqual(vError, "~error~");
+		});
+	});
+
+	//*********************************************************************************************
+	QUnit.test("patch", function (assert) {
 		var oCache = {
 				patch : function () {}
 			},
@@ -1996,11 +2081,11 @@ sap.ui.define([
 
 		this.mock(oContext).expects("withCache").withExactArgs(sinon.match.func, "")
 			.callsArgWith(0, oCache, sPath)
-			.returns(Promise.resolve());
+			.returns("~result~");
 		this.mock(oCache).expects("patch").withExactArgs(sPath, sinon.match.same(oData));
 
 		// code under test
-		return oContext.patch(oData);
+		assert.strictEqual(oContext.patch(oData), "~result~");
 	});
 
 	//*********************************************************************************************
@@ -3715,6 +3800,7 @@ sap.ui.define([
 	QUnit.test("resetChanges, w/o oDeletePromise, bInactive=" + bInactive, function (assert) {
 		var oBinding = {
 				checkSuspended : function () {},
+				getParameterContext : "must not be called",
 				resetChangesForPath : function () {}
 			},
 			oModel = {
@@ -3848,7 +3934,7 @@ sap.ui.define([
 
 	//*********************************************************************************************
 	QUnit.test("resetChanges: throws error on parameter context", function (assert) {
-		var oBinding = {getParameterContext : function () {}},
+		var oBinding = {oOperation : {}, getParameterContext : function () {}},
 			oContext = Context.create({/*oModel*/}, oBinding, "/Operation(...)/$Parameter");
 
 		this.mock(oContext).expects("isTransient").withExactArgs().returns(false);
@@ -4363,9 +4449,9 @@ sap.ui.define([
 	});
 
 	//*********************************************************************************************
-	QUnit.test("getAndRemoveValue", function (assert) {
+	QUnit.test("getAndRemoveCollection", function (assert) {
 		var oCache = {
-				getAndRemoveValue : function () {}
+				getAndRemoveCollection : function () {}
 			},
 			oContext = Context.create({/*oModel*/}, {/*oBinding*/}, "/path"),
 			oExpectation;
@@ -4375,9 +4461,10 @@ sap.ui.define([
 			.returns(SyncPromise.resolve("~valueFromWithCache~"));
 
 		// code under test
-		assert.strictEqual(oContext.getAndRemoveValue("relative/path"), "~valueFromWithCache~");
+		assert.strictEqual(oContext.getAndRemoveCollection("relative/path"),
+			"~valueFromWithCache~");
 
-		this.mock(oCache).expects("getAndRemoveValue").withExactArgs("cache/path")
+		this.mock(oCache).expects("getAndRemoveCollection").withExactArgs("cache/path")
 			.returns("~value~");
 
 		// code under test

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

@@ -3010,26 +3010,72 @@ sap.ui.define([
 });
 
 	//*********************************************************************************************
-[false, true].forEach(function (bHasCache) {
-	QUnit.test("doDeregisterChangeListener: cache=" + bHasCache, function () {
-		var oBinding = new ODataBinding(),
-			oCache = {
-				deregisterChangeListener : function () {}
+["", "relative/path"].forEach(function (sRelativePath) {
+	QUnit.test(`doDeregisterChangeListener: matching cache, path=${sRelativePath}`, function () {
+		const oCache = {
+			deregisterChangeListener : mustBeMocked
+		};
+		const oBinding = new ODataBinding({
+			oCachePromise : SyncPromise.resolve(oCache)
+		});
+
+		this.mock(oBinding).expects("getResolvedPath").withExactArgs().returns("/resolved/path");
+		this.mock(_Helper).expects("getRelativePath")
+			.withExactArgs("/absolute/path", "/resolved/path").returns(sRelativePath);
+		this.mock(oCache).expects("deregisterChangeListener")
+			.withExactArgs(sRelativePath, "~oListener~");
+
+		// code under test
+		oBinding.doDeregisterChangeListener("/absolute/path", "~oListener~");
+	});
+});
+
+	//*********************************************************************************************
+[false, true].forEach(function (bCache) {
+	QUnit.test(`doDeregisterChangeListener: no ${bCache ? "matching " : ""} cache`, function () {
+		const oBinding = new ODataBinding({
+			oCachePromise : SyncPromise.resolve(bCache ? {} : null),
+			oContext : {
+				getBinding : mustBeMocked
 			},
-			oListener = {},
-			sPath = "foo";
+			bRelative : true
+		});
+		const oParentBinding = {
+			doDeregisterChangeListener : mustBeMocked
+		};
 
-		if (bHasCache) {
-			oBinding.oCache = oCache;
-		}
-		this.mock(oCache).expects("deregisterChangeListener").exactly(bHasCache ? 1 : 0)
-			.withExactArgs(sPath, sinon.match.same(oListener));
+		this.mock(oBinding).expects("getResolvedPath").exactly(bCache ? 1 : 0)
+			.withExactArgs().returns("/resolved/path");
+		this.mock(_Helper).expects("getRelativePath").exactly(bCache ? 1 : 0)
+			.withExactArgs("/absolute/path", "/resolved/path").returns(undefined);
+		this.mock(oBinding.oContext).expects("getBinding").withExactArgs().returns(oParentBinding);
+		this.mock(oParentBinding).expects("doDeregisterChangeListener")
+			.withExactArgs("/absolute/path", "~oListener~");
 
 		// code under test
-		oBinding.doDeregisterChangeListener(sPath, oListener);
+		oBinding.doDeregisterChangeListener("/absolute/path", "~oListener~");
 	});
 });
 
+	//*********************************************************************************************
+	QUnit.test("doDeregisterChangeListener: no cache and no valid context", function () {
+		const oBinding = new ODataBinding();
+
+		// code under test - unresolved
+		oBinding.doDeregisterChangeListener();
+
+		oBinding.oContext = {getBinding : "do not call"};
+
+		// code under test - absolute with context
+		oBinding.doDeregisterChangeListener();
+
+		oBinding.bRelative = true;
+		oBinding.oContext = {};
+
+		// code under test - base context
+		oBinding.doDeregisterChangeListener();
+	});
+
 	//*********************************************************************************************
 	QUnit.test("allow for super calls", function (assert) {
 		var oBinding = new ODataBinding();