@openui5/sap.ui.core 1.119.1 → 1.120.1

package/test/sap/ui/core/qunit/ManagedObject.qunit.js

@@ -2,6 +2,7 @@
 sap.ui.define([
 	"sap/ui/base/BindingInfo",
 	"sap/ui/base/BindingParser",
+	"sap/ui/base/DataType",
 	"sap/ui/base/ManagedObject",
 	"sap/ui/core/Element",
 	"sap/ui/model/json/JSONModel",
@@ -14,18 +15,30 @@ sap.ui.define([
 	"sap/ui/model/Sorter",
 	"sap/ui/base/ManagedObjectMetadata",
 	"sap/base/strings/escapeRegExp",
-	"sap/base/util/isEmptyObject"
-], function(BindingInfo, BindingParser, ManagedObject, Element, JSONModel, Context, ManagedObjectModel, StringType, Control, Component, UIComponent, Sorter, ManagedObjectMetadata, escapeRegExp, isEmptyObject) {
+	"sap/base/util/isEmptyObject",
+	"sap/base/util/ObjectPath"
+], function(BindingInfo, BindingParser, DataType, ManagedObject, Element, JSONModel, Context, ManagedObjectModel, StringType, Control, Component, UIComponent, Sorter, ManagedObjectMetadata, escapeRegExp, isEmptyObject, ObjectPath) {
 	"use strict";
 	var mObjects = {};
 
-	var MyEnum = window.MyEnum = {
+	var MyEnum = {
 		Good: 'Good',
 		/* default */
 		Better: 'Better',
 		Best: 'Best'
 	};
 
+	DataType.registerEnum("MyEnum", MyEnum);
+
+	// sample item object, will be used as aggregation content for defaultClass test
+	const TestItem = ManagedObject.extend("sap.ui.core.TestItem", {
+		metadata: {
+			properties: {
+				name: { type: "string", defaultValue: "hello" }
+			}
+		}
+	});
+
 	// define new types for testing
 	var TestManagedObject = ManagedObject.extend("sap.ui.core.TestManagedObject", {
 		metadata : {
@@ -51,7 +64,8 @@ sap.ui.define([
 				singleBindableAggr : { type : "sap.ui.core.TestManagedObject", multiple : false, bindable: "bindable" },
 				subObjects : { type : "sap.ui.core.TestManagedObject", multiple : true, singularName : "subObj"},
 				elements : { type : "sap.ui.core.Element", multiple : true, bindable: "bindable"},
-				skippedPropagation : { type: "sap.ui.core.Element", multiple: false }
+				skippedPropagation : { type: "sap.ui.core.Element", multiple: false },
+				itemsWithDefaultClass: { type: "sap.ui.core.TestItem", defaultClass: TestItem, multiple: true}
 			},
 			associations : {
 				selectedObject : { type : "sap.ui.core.TestManagedObject", multiple : false},
@@ -1949,6 +1963,78 @@ sap.ui.define([
 		assert.ok(bThrown, "Must throw error on unknown aggregation bind");
 	});
 
+	QUnit.module("defaultClass");
+
+	QUnit.test("ManagedObjects created from object-literals", function(assert) {
+		// spy ObjectPath.get() to check if aggregations with default class don't probe the global namespace
+		const oObjectPathGetSpy = this.spy(ObjectPath, "get");
+
+		// Create aggregation content from object literals
+		const oContainer = new TestManagedObject({
+			itemsWithDefaultClass: [{
+				name: "item 0"
+			},
+			{
+				name: "item 1"
+			}]
+		});
+
+		assert.equal(oObjectPathGetSpy.callCount, 0, "No access to global namespace for aggregations with 'defaultClass'");
+
+		// check aggregation content
+		oContainer.getItemsWithDefaultClass().forEach((obj, i) => {
+			assert.ok(obj instanceof TestItem, "Aggregation Item was correctly instantiated from 'defaultClass'");
+			assert.ok(obj.getName(), `item ${i}`, "Aggregation Item properties correctly passed to 'defaultClass' constructor");
+		});
+
+		oObjectPathGetSpy.restore();
+	});
+
+	QUnit.test("validation: defaultClass does not match aggregation type", function(assert) {
+		assert.throws(() => {
+			// sample item object, will be used as aggregation content for defaultClass test
+			ManagedObject.extend("sap.ui.core.FaultyTestClass", {
+				metadata: {
+					aggregations: {
+						items: { type: "sap.ui.core.TestItem", defaultClass: ManagedObject }
+					}
+				}
+			});
+		},
+		new TypeError("The 'defaultClass' of the aggregation 'items' in 'sap.ui.core.FaultyTestClass' is not of type 'sap.ui.core.TestItem'."),
+		"'defaultClass' definition not matching aggregation type leads to a TypeError");
+	});
+
+	QUnit.test("validation: defaultClass is defined together with altTypes containing 'object'", function(assert) {
+		assert.throws(() => {
+			// sample item object, will be used as aggregation content for defaultClass test
+			ManagedObject.extend("sap.ui.core.FaultyTestClass", {
+				metadata: {
+					aggregations: {
+						items: { type: "sap.ui.base.ManagedObject", defaultClass: ManagedObject, altTypes: ["string", "object"] }
+					}
+				}
+			});
+		},
+		new TypeError("The aggregation 'items' in 'sap.ui.core.FaultyTestClass' must not defined a 'defaultClass' together with the altType 'object'."),
+		"'defaultClass' definition together with 'altTypes' definition containing 'object' leads to a TypeError");
+	});
+
+	QUnit.test("validation: defaultClass property is defined, but nullish", function(assert) {
+		assert.throws(() => {
+			// sample item object, will be used as aggregation content for defaultClass test
+			ManagedObject.extend("sap.ui.core.FaultyTestClass", {
+				metadata: {
+					aggregations: {
+						items: { type: "sap.ui.base.ManagedObject", defaultClass: undefined }
+					}
+				}
+			});
+		},
+		new TypeError("The 'defaultClass' of the aggregation 'items' in 'sap.ui.core.FaultyTestClass' is defined with a nullish value (undefined)."),
+		"'defaultClass' definition with nullish value leads to a TypeError");
+	});
+
 	QUnit.module("Hidden Aggregations", {
 		beforeEach: function() {
 			this.testObj = new sapTestTestManagedObject("testObj", {

package/test/sap/ui/core/qunit/ManagedObjectMetadata.qunit.js

@@ -8,7 +8,7 @@ sap.ui.define([
 	"sap/ui/base/ManagedObject",
 	"sap/ui/core/Element",
 	"sap/ui/core/CustomData",
-	"sap/ui/core/Configuration",
+	"sap/ui/core/Lib",
 	"sap/ui/thirdparty/jquery"
 ],
 function(
@@ -16,7 +16,7 @@ function(
 	ManagedObject,
 	Element,
 	CustomData,
-	Configuration,
+	Library,
 	jQuery
 ) {
 	"use strict";
@@ -160,6 +160,9 @@ function(
 			this.oRequireStub.withArgs(["sap/test/otherInstanceSpecific.designtime"]).callsArgWithAsync(1, this.oDTForOtherInstance);
 			this.oRequireStub.withArgs(["sap/test/instanceSpecificFunction.designtime"]).callsArgWithAsync(1, this.oDTForInstanceFunction);
 			this.oRequireStub.withArgs(["sap/ui/dt/defaultDesigntime/defaultDT.designtime"]).callsArgWithAsync(1, this.oDTForPredefinedDefaultDT);
+			// For some reason sinon v1 must be used for this test which does not support callThrough on stubs therefore implemented a stub for
+			// the sap.ui.require(["sap/ui/core/Lib"]) call
+			this.oRequireStub.withArgs(["sap/ui/core/Lib"]).callsArgWithAsync(1, Library);
 
 			this.oInstanceWithoutSpecificDTMetadata = new Element();
 			this.oInstanceWithSpecificDTMetadata = new Element({
@@ -427,7 +430,7 @@ function(
 			]).then(function(aDesignTimes) {
 
 				// Only 3 require calls are expected, as one ManagedObject (NoDTManagedObjectChild2) does not have design time data
-				sinon.assert.callCount(this.oRequireStub, 3);
+				sinon.assert.callCount(this.oRequireStub, 6);
 
 				var oDTManagedObjectDesignTime = aDesignTimes[0];
 				assert.strictEqual(oDTManagedObjectDesignTime.metaProp1, "1", "DesignTime data was passed");
@@ -471,7 +474,7 @@ function(
 		QUnit.test("loadDesignTime - cache the results", function(assert) {
 			var oDTManagedObjectMetadata = DTManagedObjectChild3.getMetadata();
 			return oDTManagedObjectMetadata.loadDesignTime().then(function() {
-				sinon.assert.callCount(this.oRequireStub, 3);
+				sinon.assert.callCount(this.oRequireStub, 6);
 				this.oRequireStub.reset();
 				return oDTManagedObjectMetadata.loadDesignTime().then(function() {
 					assert.notOk(this.oRequireStub.called, "sap.ui.require was not called");
@@ -481,17 +484,17 @@ function(
 
 		QUnit.test("loadDesignTime - cache the results implicitly (parent first)", function(assert) {
 			return DTManagedObjectChild.getMetadata().loadDesignTime().then(function() {
-				sinon.assert.callCount(this.oRequireStub, 2);
+				sinon.assert.callCount(this.oRequireStub, 4);
 				this.oRequireStub.reset();
 				return DTManagedObjectChild3.getMetadata().loadDesignTime().then(function() {
-					sinon.assert.callCount(this.oRequireStub, 1);
+					sinon.assert.callCount(this.oRequireStub, 2);
 				}.bind(this));
 			}.bind(this));
 		});
 
 		QUnit.test("loadDesignTime - cache the results implicitly (child first)", function(assert) {
 			return DTManagedObjectChild3.getMetadata().loadDesignTime().then(function() {
-				sinon.assert.callCount(this.oRequireStub, 3);
+				sinon.assert.callCount(this.oRequireStub, 6);
 				this.oRequireStub.reset();
 				return DTManagedObjectChild.getMetadata().loadDesignTime().then(function() {
 					assert.notOk(this.oRequireStub.called, "sap.ui.require was not called");
@@ -499,38 +502,33 @@ function(
 			}.bind(this));
 		});
 
-		QUnit.test("loadDesignTime - cache the results implicitly (child  with parent + other child with same parent)", function(assert) {
-			return DTManagedObjectChild.getMetadata().loadDesignTime().then(function(oTestOuter) {
-				sinon.assert.callCount(this.oRequireStub, 2);
-				this.oRequireStub.reset();
-				//previously the issue was that a derived control deleted the parents designtimeModule.
-				//any other child did not set the correct designtimeModule path
-
-				//load derived metadata DTManagedObjectChild3 that inherits DTManagedObject
-				DTManagedObjectChild3.getMetadata().loadDesignTime().then(function(oTestOuter3) {
-					sinon.assert.callCount(this.oRequireStub, 1);
-					this.oRequireStub.reset();
-					return DTManagedObject.getMetadata().loadDesignTime().then(function(oTestInner) {
-						assert.strictEqual(oTestInner.designtimeModule, "DTManagedObject.designtime", "DesignTime module path defined DTManagedObjectChild");
-					}.bind(this)).then(function() {
-						assert.strictEqual(oTestOuter3.designtimeModule, "DTManagedObjectChild3.designtime", "DesignTime module path defined DTManagedObjectChild3");
-					});
-				}.bind(this));
-				//load derived metadata DTManagedObjectChild3 that inherits DTManagedObjectChild
-				DTManagedObjectChild.getMetadata().loadDesignTime().then(function(oTestInner) {
-					return DTManagedObject.getMetadata().loadDesignTime().then(function(oTestInner2) {
-						assert.strictEqual(oTestInner2.designtimeModule, "DTManagedObject.designtime", "DesignTime module path defined DTManagedObjectChild");
-					}.bind(this)).then(function() {
-						assert.strictEqual(oTestInner.designtimeModule, "DTManagedObjectChild.designtime", "DesignTime module path defined DTManagedObjectChild, parent still valid");
-					});
-				}.bind(this));
-			}.bind(this));
+		QUnit.test("loadDesignTime - cache the results implicitly (child  with parent + other child with same parent)", async function(assert) {
+			await DTManagedObjectChild.getMetadata().loadDesignTime();
+			sinon.assert.callCount(this.oRequireStub, 4);
+			this.oRequireStub.reset();
+
+			//previously the issue was that a derived control deleted the parents designtimeModule.
+			//any other child did not set the correct designtimeModule path
+
+			//load derived metadata DTManagedObjectChild3 that inherits DTManagedObject
+			const oTestOuter3 = await DTManagedObjectChild3.getMetadata().loadDesignTime();
+			sinon.assert.callCount(this.oRequireStub, 2);
+			this.oRequireStub.reset();
+
+			let oTestInner = await DTManagedObject.getMetadata().loadDesignTime();
+			assert.strictEqual(oTestInner.designtimeModule, "DTManagedObject.designtime", "DesignTime module path defined DTManagedObjectChild");
+			assert.strictEqual(oTestOuter3.designtimeModule, "DTManagedObjectChild3.designtime", "DesignTime module path defined DTManagedObjectChild3");
+
+			oTestInner = await DTManagedObjectChild.getMetadata().loadDesignTime();
+			const oTestInner2 = await DTManagedObject.getMetadata().loadDesignTime();
+			assert.strictEqual(oTestInner2.designtimeModule, "DTManagedObject.designtime", "DesignTime module path defined DTManagedObjectChild");
+			assert.strictEqual(oTestInner.designtimeModule, "DTManagedObjectChild.designtime", "DesignTime module path defined DTManagedObjectChild, parent still valid");
 		});
 
 		QUnit.test("loadDesignTime - cache the results with designtime only via inheritance", function(assert) {
 			var oDTManagedObjectMetadataChild = NoDTManagedObjectChild2.getMetadata();
 			return oDTManagedObjectMetadataChild.loadDesignTime().then(function(oDesignTime) {
-				sinon.assert.callCount(this.oRequireStub, 2);
+				sinon.assert.callCount(this.oRequireStub, 4);
 				this.oRequireStub.reset();
 				return oDTManagedObjectMetadataChild.loadDesignTime().then(function() {
 					assert.notOk(this.oRequireStub.called, "sap.ui.require was not called");
@@ -575,7 +573,7 @@ function(
 		}
 	}, function () {
 		QUnit.test("loadDesignTime - from core for custom data no preload", function(assert) {
-			this.oConfigurationGetPreloadStub = sinon.stub(Configuration, "getPreload").returns("");
+			this.oLibraryGetPreloadStub = sinon.stub(Library, "getPreloadMode").returns("");
 			this.spy(sap.ui, 'require');
 			this.spy(privateLoaderAPI, 'loadJSResourceAsync');
 			return this.oMetadata.loadDesignTime().then(function(oDesignTime) {
@@ -586,13 +584,13 @@ function(
 				assert.ok(sap.ui.require.calledWith(["sap/ui/core/designtime/CustomData.designtime"]), "CustomData.designtime.js was required");
 				assert.ok(oDesignTime._oLib !== undefined, "sap/ui/core/designtime/library.designtime.js is available in designtime object");
 			}.bind(this)).finally(function () {
-				this.oConfigurationGetPreloadStub.restore();
+				this.oLibraryGetPreloadStub.restore();
 			}.bind(this));
 		});
 
 		QUnit.test("loadDesignTime - from core for custom data with preload async", function(assert) {
 			//async configuration simulation
-			this.oConfigurationGetPreloadStub = sinon.stub(Configuration, "getPreload").returns("async");
+			this.oLibraryGetPreloadStub = sinon.stub(Library, "getPreloadMode").returns("async");
 			this.spy(sap.ui, 'require');
 			this.spy(privateLoaderAPI, 'loadJSResourceAsync');
 
@@ -608,13 +606,13 @@ function(
 				assert.ok(sap.ui.require.calledWith(["sap/ui/core/designtime/CustomData.designtime"]), "CustomData.designtime.js was required");
 				assert.ok(oDesignTime._oLib !== undefined, "sap/ui/core/designtime/library.designtime.js loaded");
 			}.bind(this)).finally(function () {
-				this.oConfigurationGetPreloadStub.restore();
+				this.oLibraryGetPreloadStub.restore();
 			}.bind(this));
 		});
 
 		QUnit.test("loadDesignTime - from core for custom data with preload sync", function(assert) {
 			//sync configuration simulation
-			this.oConfigurationGetPreloadStub = sinon.stub(Configuration, "getPreload").returns("sync");
+			this.oLibraryGetPreloadStub = sinon.stub(Library, "getPreloadMode").returns("sync");
 			this.spy(sap.ui, 'require');
 			this.spy(privateLoaderAPI, 'loadJSResourceAsync');
 
@@ -630,7 +628,7 @@ function(
 				assert.ok(sap.ui.require.calledWith(["sap/ui/core/designtime/CustomData.designtime"]), "CustomData.designtime.js was required");
 				assert.ok(oDesignTime._oLib !== undefined, "sap/ui/core/designtime/library.designtime.js loaded");
 			}.bind(this)).finally(function () {
-				this.oConfigurationGetPreloadStub.restore();
+				this.oLibraryGetPreloadStub.restore();
 			}.bind(this));
 		});
 	});
@@ -712,6 +710,9 @@ function(
 			this.oRequireStub.withArgs(["DTManagedObjectChild.designtime"]).callsArgWithAsync(1, this.oDTForManagedObjectChild);
 			this.oRequireStub.withArgs(["sap/test/instanceSpecific.designtime"]).callsArgWithAsync(1, this.oDTForInstance);
 			this.oRequireStub.withArgs(["sap/test/otherInstanceSpecific.designtime"]).callsArgWithAsync(1, this.oDTForOtherInstance);
+			// For some reason sinon v1 must be used for this test which does not support callThrough on stubs therefore implemented a stub for
+			// the sap.ui.require(["sap/ui/core/Lib"]) call
+			this.oRequireStub.withArgs(["sap/ui/core/Lib"]).callsArgWithAsync(1, Library);
 
 			this.oInstanceWithoutSpecificDTMetadata = new Element();
 			this.oInstanceWithSpecificDTMetadata = new Element({

package/test/sap/ui/core/qunit/ManagedObjectModel.qunit.js

@@ -11,12 +11,13 @@ sap.ui.define([
 	"sap/ui/core/mvc/XMLView",
 	"sap/ui/model/base/ManagedObjectModel",
 	"sap/ui/model/json/JSONModel",
+	"sap/ui/model/type/Boolean",
 	"sap/ui/model/type/Date",
 	"sap/ui/model/Context",
 	"sap/ui/model/Filter",
 	"sap/ui/model/FilterOperator"
 ], function (CustomListItem, DatePicker, Input, List, Select, Text, VBox, Element, Item, XMLView,
-			 ManagedObjectModel, JSONModel, DateType, Context, Filter, FilterOperator) {
+			 ManagedObjectModel, JSONModel, BooleanType, DateType, Context, Filter, FilterOperator) {
 	/*global QUnit */
 	/*eslint no-warning-comments: 0 */
 	"use strict";

package/test/sap/ui/core/qunit/{ManagedObject_noBoot.qunit.js → ManagedObject_BindingParser.qunit.js}

@@ -1,26 +1,27 @@
 /* global QUnit */
 sap.ui.define([
-	"sap/ui/core/Control"
-], function(Control) {
+	"sap/ui/base/BindingInfo",
+	"sap/ui/base/BindingParser"
+], function(
+	BindingInfo,
+	BindingParser
+) {
 	"use strict";
 
 	QUnit.module("FLP Boot Scenario");
 
-	QUnit.test("Check binding parser is set correctly after core is booted", function (assert) {
+	QUnit.test("Check binding parser is set correctly after core is booted and FLP changed the bindingSyntax configuration", function (assert) {
 		assert.expect(1);
 		var done = assert.async();
-
 		// load config file as in FLP boot scenario with specific config before core is loaded
 		sap.ui.require(["testdata/core/testdata/customboot/common.configure.ui5"], function () {
 			// load core and check that bindingparser is correctly derived from config after core was loaded
 			sap.ui.require(["sap/ui/core/Core"], function(Core) {
-				var oControl = new Control({
-					busy: "{ path: '/test'}"
-				});
-				assert.strictEqual(oControl.getBindingInfo("busy").parts[0].path, "/test", "Check that complex binding path was parsed corretly by complexparser");
+				assert.equal(BindingInfo.parse, BindingParser.complexParser, "compatversion set by 'FLP' results in a complexParser");
 				done();
 			}, function(oErr) {
-				assert.strictEqual(oErr, {}, "requiring the Core must not fail");
+				assert.ok(false, "requiring the Core must not fail");
+				done();
 			});
 		});
 	});

package/test/sap/ui/core/qunit/Object.qunit.js

@@ -160,6 +160,9 @@ sap.ui.define([
 
 	QUnit.module("Base Class Functions");
 
+	/**
+	 * @deprecated As of version 1.120
+	 */
 	QUnit.test("isA static function", function(assert) {
 		var oIcon = new Icon();
 		assert.strictEqual(BaseObject.isA(oIcon, "sap.ui.core.Icon"), true, "self test: instance is a sap.ui.core.Icon");
@@ -192,4 +195,37 @@ sap.ui.define([
 		assert.strictEqual(BaseObject.isA(NaN, "sap.ui.base.Object"), false, "NaN is not BaseObject");
 		assert.strictEqual(BaseObject.isA("", "sap.ui.base.Object"), false, "Empty string is not BaseObject");
 	});
+
+	QUnit.test("isObjectA static function", function(assert) {
+		var oIcon = new Icon();
+		assert.strictEqual(BaseObject.isObjectA(oIcon, "sap.ui.core.Icon"), true, "self test: instance is a sap.ui.core.Icon");
+		assert.strictEqual(BaseObject.isObjectA(oIcon, "sap.ui.base.ManagedObject"), true, "inheritance: instance is a ManagedObject");
+		assert.strictEqual(BaseObject.isObjectA(oIcon, "sap.ui.base.Object"), true, "inheritance: instance is a BaseObject");
+		assert.strictEqual(BaseObject.isObjectA(oIcon, [
+			"sap.ui.base.Object",
+			"sap.test.rainbow"
+		]), true, "multiple: instance is a 'sap.test.rainbow' (doesn't exist) or BaseObject");
+
+		assert.strictEqual(BaseObject.isObjectA(oIcon, "sap.ui.core.HTML"), false, "Icon is not HTML");
+		assert.strictEqual(BaseObject.isObjectA(oIcon, null), false, "null check");
+		assert.strictEqual(BaseObject.isObjectA(oIcon, ""), false, "'' check");
+		assert.strictEqual(BaseObject.isObjectA(oIcon), false, "undefined check");
+		assert.strictEqual(BaseObject.isObjectA(oIcon), false, "undefined check");
+		assert.strictEqual(BaseObject.isObjectA(oIcon, [
+			"sap.test.pony",
+			"sap.test.rainbow"
+		]), false, "multiple: instance is not 'sap.test.pony' or 'sap.test.rainbow'");
+
+		var MyClass = function() {};
+		MyClass.prototype.isA = function() {
+			assert.ok(false, "Custom 'isA' method should not be called");
+		};
+		var oMyObject = new MyClass();
+		assert.strictEqual(BaseObject.isObjectA(oMyObject, "sap.ui.base.Object"), false, "MyClass is not BaseObject");
+		assert.strictEqual(BaseObject.isObjectA({}, "sap.ui.base.Object"), false, "Plain Object is not BaseObject");
+		assert.strictEqual(BaseObject.isObjectA(null, "sap.ui.base.Object"), false, "null is not BaseObject");
+		assert.strictEqual(BaseObject.isObjectA(undefined, "sap.ui.base.Object"), false, "undefined is not BaseObject");
+		assert.strictEqual(BaseObject.isObjectA(NaN, "sap.ui.base.Object"), false, "NaN is not BaseObject");
+		assert.strictEqual(BaseObject.isObjectA("", "sap.ui.base.Object"), false, "Empty string is not BaseObject");
+	});
 });