@sap/open.fe 1.98.0 → 1.99.0

package/packages/sap.fe.core/test/sap/fe/core/jest/controls/FilterBar.spec.js

@@ -0,0 +1,355 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2021 SAP SE. All rights reserved
+ */
+sap.ui.define(["sap/fe/core/converters/controls/ListReport/FilterBar"], function (FilterBar) {
+  "use strict";
+
+  var getSpecificAllowedExpression = FilterBar.getSpecificAllowedExpression;
+  var isMultiValue = FilterBar.isMultiValue;
+  var getNavigationRestrictions = FilterBar.getNavigationRestrictions;
+  var displayMode = FilterBar.displayMode;
+  var getFilterRestrictions = FilterBar.getFilterRestrictions;
+  var getModelType = FilterBar.getModelType;
+
+  describe("FilterBar", function () {
+    describe("getModelType", function () {
+      it("Boolean", function () {
+        try {
+          expect(getModelType("Edm.Boolean")).toBe("Bool");
+          return Promise.resolve();
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      });
+      it("Byte", function () {
+        try {
+          expect(getModelType("Edm.Byte")).toBe("Int");
+          return Promise.resolve();
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      });
+      it("Date", function () {
+        try {
+          expect(getModelType("Edm.Date")).toBe("Date");
+          return Promise.resolve();
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      });
+      it("String", function () {
+        try {
+          expect(getModelType("Edm.String")).toBe("String");
+          return Promise.resolve();
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      });
+    });
+    describe("getFilterRestrictions", function () {
+      it("no restrictions", function () {
+        try {
+          var oMockFilterRestrictions = {};
+          var sMockRestrictions = "";
+          expect(getFilterRestrictions(oMockFilterRestrictions, sMockRestrictions)).toEqual({});
+          return Promise.resolve();
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      });
+      it("with RequiredProperties", function () {
+        try {
+          var oMockFilterRestrictions = {
+            "RequiredProperties": [{
+              name: "SalesOrder",
+              value: "SalesOrder",
+              $PropertyPath: "SalesOrder"
+            }, {
+              name: "SoldToParty",
+              value: "SoldToParty",
+              label: "Sold-To Party"
+            }]
+          };
+          var sMockRestrictions = "RequiredProperties";
+          expect(getFilterRestrictions(oMockFilterRestrictions, sMockRestrictions)).toEqual(["SalesOrder", "SoldToParty"]);
+          return Promise.resolve();
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      });
+      it("with Filterableproperties", function () {
+        try {
+          var oMockFilterRestrictions = {
+            FilterExpressionRestrictions: [{
+              $Type: "Org.OData.Capabilities.V1.FilterExpressionRestrictionType",
+              AllowedExpressions: "SingleValue",
+              Property: {
+                fullyQualifiedName: "com.c_salesordermanage_sd.EntityContainer/SalesOrderManage@Org.OData.Capabilities.V1.FilterRestrictions/FilterExpressionRestrictions/0/Property",
+                type: "PropertyPath",
+                value: "SoldToParty"
+              }
+            }, {
+              $Type: "Org.OData.Capabilities.V1.FilterExpressionRestrictionType",
+              AllowedExpressions: "SingleRange",
+              Property: {
+                fullyQualifiedName: "com.c_salesordermanage_sd.EntityContainer/SalesOrderManage@Org.OData.Capabilities.V1.FilterRestrictions/FilterExpressionRestrictions/1/Property",
+                type: "PropertyPath",
+                value: "SalesOrderDate"
+              }
+            }]
+          };
+          var sMockRestrictions = "FilterAllowedExpressions";
+          expect(getFilterRestrictions(oMockFilterRestrictions, sMockRestrictions)).toEqual({
+            SalesOrderDate: ["SingleRange"],
+            SoldToParty: ["SingleValue"]
+          });
+          return Promise.resolve();
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      });
+      it("with Filterableproperties", function () {
+        try {
+          var oMockFilterRestrictions = {
+            FilterExpressionRestrictions: [{
+              $Type: "Org.OData.Capabilities.V1.FilterExpressionRestrictionType",
+              AllowedExpressions: "SingleValue",
+              Property: {
+                fullyQualifiedName: "com.c_salesordermanage_sd.EntityContainer/SalesOrderManage@Org.OData.Capabilities.V1.FilterRestrictions/FilterExpressionRestrictions/0/Property",
+                type: "PropertyPath",
+                value: "SoldToParty"
+              }
+            }, {
+              $Type: "Org.OData.Capabilities.V1.FilterExpressionRestrictionType",
+              AllowedExpressions: "AllowedExp1",
+              Property: {
+                fullyQualifiedName: "com.c_salesordermanage_sd.EntityContainer/SalesOrderManage@Org.OData.Capabilities.V1.FilterRestrictions/FilterExpressionRestrictions/1/Property",
+                type: "PropertyPath",
+                value: "SalesOrderDate"
+              }
+            }, {
+              $Type: "Org.OData.Capabilities.V1.FilterExpressionRestrictionType",
+              AllowedExpressions: "AllowedExp2",
+              Property: {
+                fullyQualifiedName: "com.c_salesordermanage_sd.EntityContainer/SalesOrderManage@Org.OData.Capabilities.V1.FilterRestrictions/FilterExpressionRestrictions/1/Property",
+                type: "PropertyPath",
+                value: "SalesOrderDate"
+              }
+            }]
+          };
+          var sMockRestrictions = "FilterAllowedExpressions";
+          expect(getFilterRestrictions(oMockFilterRestrictions, sMockRestrictions)).toEqual({
+            SalesOrderDate: ["AllowedExp1", "AllowedExp2"],
+            SoldToParty: ["SingleValue"]
+          });
+          return Promise.resolve();
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      });
+    });
+    describe("getNavigationRestrictions", function () {
+      it("no restrictions", function () {
+        try {
+          var mockConverterContext = {
+            getEntitySet: function () {
+              return {};
+            }
+          };
+          var mockNavigationPath = "";
+          expect(getNavigationRestrictions(mockConverterContext, mockNavigationPath)).toBeUndefined();
+          return Promise.resolve();
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      });
+      it("with navigation restrictions", function () {
+        var mockConverterContext = {
+          getEntitySet: function () {
+            return {
+              annotations: {
+                Capabilities: {
+                  NavigationRestrictions: {
+                    $Type: "Org.OData.Capabilities.V1.NavigationRestrictionsType",
+                    fullyQualifiedName: "com.c_salesordermanage_sd.EntityContainer/SalesOrderManage@Org.OData.Capabilities.V1.NavigationRestrictions",
+                    RestrictedProperties: [{
+                      $Type: "Org.OData.Capabilities.V1.NavigationPropertyRestriction",
+                      NavigationProperty: {
+                        value: "_Item"
+                      }
+                    }, {
+                      $Type: "Org.OData.Capabilities.V1.NavigationPropertyRestriction",
+                      NavigationProperty: {
+                        $NavigationPropertyPath: "_OverallSDProcessStatus"
+                      }
+                    }]
+                  }
+                }
+              }
+            };
+          }
+        };
+        var mockNavigationPath = "_Item";
+        expect(getNavigationRestrictions(mockConverterContext, mockNavigationPath)).toEqual({
+          $Type: "Org.OData.Capabilities.V1.NavigationPropertyRestriction",
+          NavigationProperty: {
+            value: "_Item"
+          }
+        });
+      });
+    });
+    describe("displayMode", function () {
+      it("no text and text arrangement annotation", function () {
+        try {
+          var mockPropertyAnnotations = {
+            Common: {}
+          };
+          var mockCollectionAnnotations = {};
+          expect(displayMode(mockPropertyAnnotations, mockCollectionAnnotations)).toBe("Value");
+          return Promise.resolve();
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      });
+      it("no text arrangement annotation", function () {
+        try {
+          var mockPropertyAnnotations = {
+            Common: {
+              Text: {
+                term: "com.sap.vocabularies.Common.v1.Text",
+                path: "_OverallSDProcessStatus/OverallSDProcessStatus_Text"
+              }
+            }
+          };
+          var mockCollectionAnnotations = {};
+          expect(displayMode(mockPropertyAnnotations, mockCollectionAnnotations)).toBe("DescriptionValue");
+          return Promise.resolve();
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      });
+      it("with text arrangment annotation - TextOnly", function () {
+        try {
+          var mockPropertyAnnotations = {
+            Common: {
+              Text: {
+                annotations: {
+                  UI: {
+                    TextArrangement: "UI.TextArrangementType/TextOnly"
+                  }
+                }
+              }
+            }
+          };
+          var mockCollectionAnnotations = {};
+          expect(displayMode(mockPropertyAnnotations, mockCollectionAnnotations)).toBe("Description");
+          return Promise.resolve();
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      });
+      it("with text arrangment annotation - TextLast", function () {
+        try {
+          var mockPropertyAnnotations = {
+            Common: {
+              Text: {
+                term: "com.sap.vocabularies.Common.v1.Text",
+                path: "_OverallSDProcessStatus/OverallSDProcessStatus_Text"
+              }
+            }
+          };
+          var mockCollectionAnnotations = {
+            UI: {
+              TextArrangement: "UI.TextArrangementType/TextLast"
+            }
+          };
+          expect(displayMode(mockPropertyAnnotations, mockCollectionAnnotations)).toBe("ValueDescription");
+          return Promise.resolve();
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      });
+      it("with text arrangment annotation - TextFirst / Default", function () {
+        try {
+          var mockPropertyAnnotations = {
+            Common: {
+              Text: {
+                term: "com.sap.vocabularies.Common.v1.Text",
+                path: "_OverallSDProcessStatus/OverallSDProcessStatus_Text"
+              }
+            }
+          };
+          var mockCollectionAnnotations = {
+            UI: {
+              TextArrangement: "UI.TextArrangementType/TextFirst"
+            }
+          };
+          expect(displayMode(mockPropertyAnnotations, mockCollectionAnnotations)).toBe("DescriptionValue");
+          return Promise.resolve();
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      });
+    });
+    describe("isMultiValue", function () {
+      it("multivalue", function () {
+        try {
+          var mockProperty = {
+            filterExpression: "MultiRange"
+          };
+          expect(isMultiValue(mockProperty)).toBeTruthy();
+          return Promise.resolve();
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      });
+      it("not multivalue - SearchExpression / Single Range / Single Value", function () {
+        try {
+          var mockProperty = {
+            filterExpression: "SingleRange"
+          };
+          expect(isMultiValue(mockProperty)).toBeFalsy();
+          return Promise.resolve();
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      });
+      it("no filter expression", function () {
+        try {
+          var mockProperty = {
+            type: ["String"]
+          };
+          expect(isMultiValue(mockProperty)).toBeTruthy();
+          return Promise.resolve();
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      });
+      it("boolean type", function () {
+        try {
+          var mockProperty = {
+            filterExpression: "SingleRange",
+            type: ["Boolean"]
+          };
+          expect(isMultiValue(mockProperty)).toBeFalsy();
+          return Promise.resolve();
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      });
+    });
+    describe("getSpecificAllowedExpression", function () {
+      it("get specific expression sorted on priority", function () {
+        try {
+          var aExpression = ["SearchExpression", "MultiValue", "MultiRange"];
+          expect(getSpecificAllowedExpression(aExpression)).toBe("MultiValue");
+          return Promise.resolve();
+        } catch (e) {
+          return Promise.reject(e);
+        }
+      });
+    });
+  });
+}, false);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["FilterBar.spec.ts"],"names":["describe","it","expect","getModelType","toBe","oMockFilterRestrictions","sMockRestrictions","getFilterRestrictions","toEqual","name","value","$PropertyPath","label","FilterExpressionRestrictions","$Type","AllowedExpressions","Property","fullyQualifiedName","type","SalesOrderDate","SoldToParty","mockConverterContext","getEntitySet","mockNavigationPath","getNavigationRestrictions","toBeUndefined","annotations","Capabilities","NavigationRestrictions","RestrictedProperties","NavigationProperty","$NavigationPropertyPath","mockPropertyAnnotations","Common","mockCollectionAnnotations","displayMode","Text","term","path","UI","TextArrangement","mockProperty","filterExpression","isMultiValue","toBeTruthy","toBeFalsy","aExpression","getSpecificAllowedExpression"],"mappings":";AAAA;AACA;AACA;;;;;;;;;;;AAOAA,EAAAA,QAAQ,CAAC,WAAD,EAAc,YAAM;AAC3BA,IAAAA,QAAQ,CAAC,cAAD,EAAiB,YAAM;AAC9BC,MAAAA,EAAE,CAAC,SAAD;AAAA,YAAwB;AACzBC,UAAAA,MAAM,CAACC,YAAY,CAAC,aAAD,CAAb,CAAN,CAAoCC,IAApC,CAAyC,MAAzC;AADyB;AAEzB,SAFC;AAAA;AAAA;AAAA,QAAF;AAGAH,MAAAA,EAAE,CAAC,MAAD;AAAA,YAAqB;AACtBC,UAAAA,MAAM,CAACC,YAAY,CAAC,UAAD,CAAb,CAAN,CAAiCC,IAAjC,CAAsC,KAAtC;AADsB;AAEtB,SAFC;AAAA;AAAA;AAAA,QAAF;AAGAH,MAAAA,EAAE,CAAC,MAAD;AAAA,YAAqB;AACtBC,UAAAA,MAAM,CAACC,YAAY,CAAC,UAAD,CAAb,CAAN,CAAiCC,IAAjC,CAAsC,MAAtC;AADsB;AAEtB,SAFC;AAAA;AAAA;AAAA,QAAF;AAGAH,MAAAA,EAAE,CAAC,QAAD;AAAA,YAAuB;AACxBC,UAAAA,MAAM,CAACC,YAAY,CAAC,YAAD,CAAb,CAAN,CAAmCC,IAAnC,CAAwC,QAAxC;AADwB;AAExB,SAFC;AAAA;AAAA;AAAA,QAAF;AAGA,KAbO,CAAR;AAeAJ,IAAAA,QAAQ,CAAC,uBAAD,EAA0B,YAAM;AACvCC,MAAAA,EAAE,CAAC,iBAAD;AAAA,YAAgC;AACjC,cAAII,uBAAuB,GAAG,EAA9B;AACA,cAAIC,iBAAiB,GAAG,EAAxB;AACAJ,UAAAA,MAAM,CAACK,qBAAqB,CAACF,uBAAD,EAA0BC,iBAA1B,CAAtB,CAAN,CAA0EE,OAA1E,CAAkF,EAAlF;AAHiC;AAIjC,SAJC;AAAA;AAAA;AAAA,QAAF;AAMAP,MAAAA,EAAE,CAAC,yBAAD;AAAA,YAAwC;AACzC,cAAII,uBAAuB,GAAG;AAC7B,kCAAsB,CACrB;AACCI,cAAAA,IAAI,EAAE,YADP;AAECC,cAAAA,KAAK,EAAE,YAFR;AAGCC,cAAAA,aAAa,EAAE;AAHhB,aADqB,EAMrB;AACCF,cAAAA,IAAI,EAAE,aADP;AAECC,cAAAA,KAAK,EAAE,aAFR;AAGCE,cAAAA,KAAK,EAAE;AAHR,aANqB;AADO,WAA9B;AAcA,cAAIN,iBAAiB,GAAG,oBAAxB;AACAJ,UAAAA,MAAM,CAACK,qBAAqB,CAACF,uBAAD,EAA0BC,iBAA1B,CAAtB,CAAN,CAA0EE,OAA1E,CAAkF,CAAC,YAAD,EAAe,aAAf,CAAlF;AAhByC;AAiBzC,SAjBC;AAAA;AAAA;AAAA,QAAF;AAmBAP,MAAAA,EAAE,CAAC,2BAAD;AAAA,YAA0C;AAC3C,cAAII,uBAAuB,GAAG;AAC7BQ,YAAAA,4BAA4B,EAAE,CAC7B;AACCC,cAAAA,KAAK,EAAE,2DADR;AAECC,cAAAA,kBAAkB,EAAE,aAFrB;AAGCC,cAAAA,QAAQ,EAAE;AACTC,gBAAAA,kBAAkB,EACjB,iJAFQ;AAGTC,gBAAAA,IAAI,EAAE,cAHG;AAITR,gBAAAA,KAAK,EAAE;AAJE;AAHX,aAD6B,EAW7B;AACCI,cAAAA,KAAK,EAAE,2DADR;AAECC,cAAAA,kBAAkB,EAAE,aAFrB;AAGCC,cAAAA,QAAQ,EAAE;AACTC,gBAAAA,kBAAkB,EACjB,iJAFQ;AAGTC,gBAAAA,IAAI,EAAE,cAHG;AAITR,gBAAAA,KAAK,EAAE;AAJE;AAHX,aAX6B;AADD,WAA9B;AAwBA,cAAIJ,iBAAiB,GAAG,0BAAxB;AACAJ,UAAAA,MAAM,CAACK,qBAAqB,CAACF,uBAAD,EAA0BC,iBAA1B,CAAtB,CAAN,CAA0EE,OAA1E,CAAkF;AACjFW,YAAAA,cAAc,EAAE,CAAC,aAAD,CADiE;AAEjFC,YAAAA,WAAW,EAAE,CAAC,aAAD;AAFoE,WAAlF;AA1B2C;AA8B3C,SA9BC;AAAA;AAAA;AAAA,QAAF;AAgCAnB,MAAAA,EAAE,CAAC,2BAAD;AAAA,YAA0C;AAC3C,cAAII,uBAAuB,GAAG;AAC7BQ,YAAAA,4BAA4B,EAAE,CAC7B;AACCC,cAAAA,KAAK,EAAE,2DADR;AAECC,cAAAA,kBAAkB,EAAE,aAFrB;AAGCC,cAAAA,QAAQ,EAAE;AACTC,gBAAAA,kBAAkB,EACjB,iJAFQ;AAGTC,gBAAAA,IAAI,EAAE,cAHG;AAITR,gBAAAA,KAAK,EAAE;AAJE;AAHX,aAD6B,EAW7B;AACCI,cAAAA,KAAK,EAAE,2DADR;AAECC,cAAAA,kBAAkB,EAAE,aAFrB;AAGCC,cAAAA,QAAQ,EAAE;AACTC,gBAAAA,kBAAkB,EACjB,iJAFQ;AAGTC,gBAAAA,IAAI,EAAE,cAHG;AAITR,gBAAAA,KAAK,EAAE;AAJE;AAHX,aAX6B,EAqB7B;AACCI,cAAAA,KAAK,EAAE,2DADR;AAECC,cAAAA,kBAAkB,EAAE,aAFrB;AAGCC,cAAAA,QAAQ,EAAE;AACTC,gBAAAA,kBAAkB,EACjB,iJAFQ;AAGTC,gBAAAA,IAAI,EAAE,cAHG;AAITR,gBAAAA,KAAK,EAAE;AAJE;AAHX,aArB6B;AADD,WAA9B;AAkCA,cAAIJ,iBAAiB,GAAG,0BAAxB;AACAJ,UAAAA,MAAM,CAACK,qBAAqB,CAACF,uBAAD,EAA0BC,iBAA1B,CAAtB,CAAN,CAA0EE,OAA1E,CAAkF;AACjFW,YAAAA,cAAc,EAAE,CAAC,aAAD,EAAgB,aAAhB,CADiE;AAEjFC,YAAAA,WAAW,EAAE,CAAC,aAAD;AAFoE,WAAlF;AApC2C;AAwC3C,SAxCC;AAAA;AAAA;AAAA,QAAF;AAyCA,KAnGO,CAAR;AAqGApB,IAAAA,QAAQ,CAAC,2BAAD,EAA8B,YAAM;AAC3CC,MAAAA,EAAE,CAAC,iBAAD;AAAA,YAAgC;AACjC,cAAIoB,oBAAyB,GAAG;AAC/BC,YAAAA,YAAY,EAAE,YAAW;AACxB,qBAAO,EAAP;AACA;AAH8B,WAAhC;AAKA,cAAIC,kBAAkB,GAAG,EAAzB;AAEArB,UAAAA,MAAM,CAACsB,yBAAyB,CAACH,oBAAD,EAAuBE,kBAAvB,CAA1B,CAAN,CAA4EE,aAA5E;AARiC;AASjC,SATC;AAAA;AAAA;AAAA,QAAF;AAWAxB,MAAAA,EAAE,CAAC,8BAAD,EAAiC,YAAM;AACxC,YAAIoB,oBAAyB,GAAG;AAC/BC,UAAAA,YAAY,EAAE,YAAW;AACxB,mBAAO;AACNI,cAAAA,WAAW,EAAE;AACZC,gBAAAA,YAAY,EAAE;AACbC,kBAAAA,sBAAsB,EAAE;AACvBd,oBAAAA,KAAK,EAAE,sDADgB;AAEvBG,oBAAAA,kBAAkB,EACjB,6GAHsB;AAIvBY,oBAAAA,oBAAoB,EAAE,CACrB;AACCf,sBAAAA,KAAK,EAAE,yDADR;AAECgB,sBAAAA,kBAAkB,EAAE;AACnBpB,wBAAAA,KAAK,EAAE;AADY;AAFrB,qBADqB,EAOrB;AACCI,sBAAAA,KAAK,EAAE,yDADR;AAECgB,sBAAAA,kBAAkB,EAAE;AACnBC,wBAAAA,uBAAuB,EAAE;AADN;AAFrB,qBAPqB;AAJC;AADX;AADF;AADP,aAAP;AAyBA;AA3B8B,SAAhC;AA6BA,YAAIR,kBAAkB,GAAG,OAAzB;AACArB,QAAAA,MAAM,CAACsB,yBAAyB,CAACH,oBAAD,EAAuBE,kBAAvB,CAA1B,CAAN,CAA4Ef,OAA5E,CAAoF;AACnFM,UAAAA,KAAK,EAAE,yDAD4E;AAEnFgB,UAAAA,kBAAkB,EAAE;AACnBpB,YAAAA,KAAK,EAAE;AADY;AAF+D,SAApF;AAMA,OArCC,CAAF;AAsCA,KAlDO,CAAR;AAoDAV,IAAAA,QAAQ,CAAC,aAAD,EAAgB,YAAM;AAC7BC,MAAAA,EAAE,CAAC,yCAAD;AAAA,YAAwD;AACzD,cAAI+B,uBAAuB,GAAG;AAC7BC,YAAAA,MAAM,EAAE;AADqB,WAA9B;AAGA,cAAIC,yBAAyB,GAAG,EAAhC;AACAhC,UAAAA,MAAM,CAACiC,WAAW,CAACH,uBAAD,EAA0BE,yBAA1B,CAAZ,CAAN,CAAwE9B,IAAxE,CAA6E,OAA7E;AALyD;AAMzD,SANC;AAAA;AAAA;AAAA,QAAF;AAOAH,MAAAA,EAAE,CAAC,gCAAD;AAAA,YAA+C;AAChD,cAAI+B,uBAAuB,GAAG;AAC7BC,YAAAA,MAAM,EAAE;AACPG,cAAAA,IAAI,EAAE;AACLC,gBAAAA,IAAI,EAAE,qCADD;AAELC,gBAAAA,IAAI,EAAE;AAFD;AADC;AADqB,WAA9B;AAQA,cAAIJ,yBAAyB,GAAG,EAAhC;AACAhC,UAAAA,MAAM,CAACiC,WAAW,CAACH,uBAAD,EAA0BE,yBAA1B,CAAZ,CAAN,CAAwE9B,IAAxE,CAA6E,kBAA7E;AAVgD;AAWhD,SAXC;AAAA;AAAA;AAAA,QAAF;AAaAH,MAAAA,EAAE,CAAC,4CAAD;AAAA,YAA2D;AAC5D,cAAI+B,uBAAuB,GAAG;AAC7BC,YAAAA,MAAM,EAAE;AACPG,cAAAA,IAAI,EAAE;AACLV,gBAAAA,WAAW,EAAE;AACZa,kBAAAA,EAAE,EAAE;AACHC,oBAAAA,eAAe,EAAE;AADd;AADQ;AADR;AADC;AADqB,WAA9B;AAWA,cAAIN,yBAAyB,GAAG,EAAhC;AACAhC,UAAAA,MAAM,CAACiC,WAAW,CAACH,uBAAD,EAA0BE,yBAA1B,CAAZ,CAAN,CAAwE9B,IAAxE,CAA6E,aAA7E;AAb4D;AAc5D,SAdC;AAAA;AAAA;AAAA,QAAF;AAgBAH,MAAAA,EAAE,CAAC,4CAAD;AAAA,YAA2D;AAC5D,cAAI+B,uBAAuB,GAAG;AAC7BC,YAAAA,MAAM,EAAE;AACPG,cAAAA,IAAI,EAAE;AACLC,gBAAAA,IAAI,EAAE,qCADD;AAELC,gBAAAA,IAAI,EAAE;AAFD;AADC;AADqB,WAA9B;AAQA,cAAIJ,yBAAyB,GAAG;AAC/BK,YAAAA,EAAE,EAAE;AACHC,cAAAA,eAAe,EAAE;AADd;AAD2B,WAAhC;AAKAtC,UAAAA,MAAM,CAACiC,WAAW,CAACH,uBAAD,EAA0BE,yBAA1B,CAAZ,CAAN,CAAwE9B,IAAxE,CAA6E,kBAA7E;AAd4D;AAe5D,SAfC;AAAA;AAAA;AAAA,QAAF;AAgBAH,MAAAA,EAAE,CAAC,uDAAD;AAAA,YAAsE;AACvE,cAAI+B,uBAAuB,GAAG;AAC7BC,YAAAA,MAAM,EAAE;AACPG,cAAAA,IAAI,EAAE;AACLC,gBAAAA,IAAI,EAAE,qCADD;AAELC,gBAAAA,IAAI,EAAE;AAFD;AADC;AADqB,WAA9B;AAQA,cAAIJ,yBAAyB,GAAG;AAC/BK,YAAAA,EAAE,EAAE;AACHC,cAAAA,eAAe,EAAE;AADd;AAD2B,WAAhC;AAKAtC,UAAAA,MAAM,CAACiC,WAAW,CAACH,uBAAD,EAA0BE,yBAA1B,CAAZ,CAAN,CAAwE9B,IAAxE,CAA6E,kBAA7E;AAduE;AAevE,SAfC;AAAA;AAAA;AAAA,QAAF;AAgBA,KArEO,CAAR;AAuEAJ,IAAAA,QAAQ,CAAC,cAAD,EAAiB,YAAM;AAC9BC,MAAAA,EAAE,CAAC,YAAD;AAAA,YAA2B;AAC5B,cAAIwC,YAAY,GAAG;AAClBC,YAAAA,gBAAgB,EAAE;AADA,WAAnB;AAGAxC,UAAAA,MAAM,CAACyC,YAAY,CAACF,YAAD,CAAb,CAAN,CAAmCG,UAAnC;AAJ4B;AAK5B,SALC;AAAA;AAAA;AAAA,QAAF;AAOA3C,MAAAA,EAAE,CAAC,iEAAD;AAAA,YAAgF;AACjF,cAAIwC,YAAY,GAAG;AAClBC,YAAAA,gBAAgB,EAAE;AADA,WAAnB;AAGAxC,UAAAA,MAAM,CAACyC,YAAY,CAACF,YAAD,CAAb,CAAN,CAAmCI,SAAnC;AAJiF;AAKjF,SALC;AAAA;AAAA;AAAA,QAAF;AAOA5C,MAAAA,EAAE,CAAC,sBAAD;AAAA,YAAqC;AACtC,cAAIwC,YAAY,GAAG;AAClBvB,YAAAA,IAAI,EAAE,CAAC,QAAD;AADY,WAAnB;AAGAhB,UAAAA,MAAM,CAACyC,YAAY,CAACF,YAAD,CAAb,CAAN,CAAmCG,UAAnC;AAJsC;AAKtC,SALC;AAAA;AAAA;AAAA,QAAF;AAOA3C,MAAAA,EAAE,CAAC,cAAD;AAAA,YAA6B;AAC9B,cAAIwC,YAAY,GAAG;AAClBC,YAAAA,gBAAgB,EAAE,aADA;AAElBxB,YAAAA,IAAI,EAAE,CAAC,SAAD;AAFY,WAAnB;AAIAhB,UAAAA,MAAM,CAACyC,YAAY,CAACF,YAAD,CAAb,CAAN,CAAmCI,SAAnC;AAL8B;AAM9B,SANC;AAAA;AAAA;AAAA,QAAF;AAOA,KA7BO,CAAR;AA+BA7C,IAAAA,QAAQ,CAAC,8BAAD,EAAiC,YAAM;AAC9CC,MAAAA,EAAE,CAAC,4CAAD;AAAA,YAA2D;AAC5D,cAAI6C,WAAW,GAAG,CAAC,kBAAD,EAAqB,YAArB,EAAmC,YAAnC,CAAlB;AACA5C,UAAAA,MAAM,CAAC6C,4BAA4B,CAACD,WAAD,CAA7B,CAAN,CAAkD1C,IAAlD,CAAuD,YAAvD;AAF4D;AAG5D,SAHC;AAAA;AAAA;AAAA,QAAF;AAIA,KALO,CAAR;AAMA,GArRO,CAAR","sourceRoot":".","sourcesContent":["import {\n\tgetModelType,\n\tgetFilterRestrictions,\n\tdisplayMode,\n\tgetNavigationRestrictions,\n\tisMultiValue,\n\tgetSpecificAllowedExpression\n} from \"sap/fe/core/converters/controls/ListReport/FilterBar\";\n\ndescribe(\"FilterBar\", () => {\n\tdescribe(\"getModelType\", () => {\n\t\tit(\"Boolean\", async () => {\n\t\t\texpect(getModelType(\"Edm.Boolean\")).toBe(\"Bool\");\n\t\t});\n\t\tit(\"Byte\", async () => {\n\t\t\texpect(getModelType(\"Edm.Byte\")).toBe(\"Int\");\n\t\t});\n\t\tit(\"Date\", async () => {\n\t\t\texpect(getModelType(\"Edm.Date\")).toBe(\"Date\");\n\t\t});\n\t\tit(\"String\", async () => {\n\t\t\texpect(getModelType(\"Edm.String\")).toBe(\"String\");\n\t\t});\n\t});\n\n\tdescribe(\"getFilterRestrictions\", () => {\n\t\tit(\"no restrictions\", async () => {\n\t\t\tlet oMockFilterRestrictions = {};\n\t\t\tlet sMockRestrictions = \"\";\n\t\t\texpect(getFilterRestrictions(oMockFilterRestrictions, sMockRestrictions)).toEqual({});\n\t\t});\n\n\t\tit(\"with RequiredProperties\", async () => {\n\t\t\tlet oMockFilterRestrictions = {\n\t\t\t\t\"RequiredProperties\": [\n\t\t\t\t\t{\n\t\t\t\t\t\tname: \"SalesOrder\",\n\t\t\t\t\t\tvalue: \"SalesOrder\",\n\t\t\t\t\t\t$PropertyPath: \"SalesOrder\"\n\t\t\t\t\t},\n\t\t\t\t\t{\n\t\t\t\t\t\tname: \"SoldToParty\",\n\t\t\t\t\t\tvalue: \"SoldToParty\",\n\t\t\t\t\t\tlabel: \"Sold-To Party\"\n\t\t\t\t\t}\n\t\t\t\t]\n\t\t\t};\n\t\t\tlet sMockRestrictions = \"RequiredProperties\";\n\t\t\texpect(getFilterRestrictions(oMockFilterRestrictions, sMockRestrictions)).toEqual([\"SalesOrder\", \"SoldToParty\"]);\n\t\t});\n\n\t\tit(\"with Filterableproperties\", async () => {\n\t\t\tlet oMockFilterRestrictions = {\n\t\t\t\tFilterExpressionRestrictions: [\n\t\t\t\t\t{\n\t\t\t\t\t\t$Type: \"Org.OData.Capabilities.V1.FilterExpressionRestrictionType\",\n\t\t\t\t\t\tAllowedExpressions: \"SingleValue\",\n\t\t\t\t\t\tProperty: {\n\t\t\t\t\t\t\tfullyQualifiedName:\n\t\t\t\t\t\t\t\t\"com.c_salesordermanage_sd.EntityContainer/SalesOrderManage@Org.OData.Capabilities.V1.FilterRestrictions/FilterExpressionRestrictions/0/Property\",\n\t\t\t\t\t\t\ttype: \"PropertyPath\",\n\t\t\t\t\t\t\tvalue: \"SoldToParty\"\n\t\t\t\t\t\t}\n\t\t\t\t\t},\n\t\t\t\t\t{\n\t\t\t\t\t\t$Type: \"Org.OData.Capabilities.V1.FilterExpressionRestrictionType\",\n\t\t\t\t\t\tAllowedExpressions: \"SingleRange\",\n\t\t\t\t\t\tProperty: {\n\t\t\t\t\t\t\tfullyQualifiedName:\n\t\t\t\t\t\t\t\t\"com.c_salesordermanage_sd.EntityContainer/SalesOrderManage@Org.OData.Capabilities.V1.FilterRestrictions/FilterExpressionRestrictions/1/Property\",\n\t\t\t\t\t\t\ttype: \"PropertyPath\",\n\t\t\t\t\t\t\tvalue: \"SalesOrderDate\"\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t]\n\t\t\t};\n\t\t\tlet sMockRestrictions = \"FilterAllowedExpressions\";\n\t\t\texpect(getFilterRestrictions(oMockFilterRestrictions, sMockRestrictions)).toEqual({\n\t\t\t\tSalesOrderDate: [\"SingleRange\"],\n\t\t\t\tSoldToParty: [\"SingleValue\"]\n\t\t\t});\n\t\t});\n\n\t\tit(\"with Filterableproperties\", async () => {\n\t\t\tlet oMockFilterRestrictions = {\n\t\t\t\tFilterExpressionRestrictions: [\n\t\t\t\t\t{\n\t\t\t\t\t\t$Type: \"Org.OData.Capabilities.V1.FilterExpressionRestrictionType\",\n\t\t\t\t\t\tAllowedExpressions: \"SingleValue\",\n\t\t\t\t\t\tProperty: {\n\t\t\t\t\t\t\tfullyQualifiedName:\n\t\t\t\t\t\t\t\t\"com.c_salesordermanage_sd.EntityContainer/SalesOrderManage@Org.OData.Capabilities.V1.FilterRestrictions/FilterExpressionRestrictions/0/Property\",\n\t\t\t\t\t\t\ttype: \"PropertyPath\",\n\t\t\t\t\t\t\tvalue: \"SoldToParty\"\n\t\t\t\t\t\t}\n\t\t\t\t\t},\n\t\t\t\t\t{\n\t\t\t\t\t\t$Type: \"Org.OData.Capabilities.V1.FilterExpressionRestrictionType\",\n\t\t\t\t\t\tAllowedExpressions: \"AllowedExp1\",\n\t\t\t\t\t\tProperty: {\n\t\t\t\t\t\t\tfullyQualifiedName:\n\t\t\t\t\t\t\t\t\"com.c_salesordermanage_sd.EntityContainer/SalesOrderManage@Org.OData.Capabilities.V1.FilterRestrictions/FilterExpressionRestrictions/1/Property\",\n\t\t\t\t\t\t\ttype: \"PropertyPath\",\n\t\t\t\t\t\t\tvalue: \"SalesOrderDate\"\n\t\t\t\t\t\t}\n\t\t\t\t\t},\n\t\t\t\t\t{\n\t\t\t\t\t\t$Type: \"Org.OData.Capabilities.V1.FilterExpressionRestrictionType\",\n\t\t\t\t\t\tAllowedExpressions: \"AllowedExp2\",\n\t\t\t\t\t\tProperty: {\n\t\t\t\t\t\t\tfullyQualifiedName:\n\t\t\t\t\t\t\t\t\"com.c_salesordermanage_sd.EntityContainer/SalesOrderManage@Org.OData.Capabilities.V1.FilterRestrictions/FilterExpressionRestrictions/1/Property\",\n\t\t\t\t\t\t\ttype: \"PropertyPath\",\n\t\t\t\t\t\t\tvalue: \"SalesOrderDate\"\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t]\n\t\t\t};\n\t\t\tlet sMockRestrictions = \"FilterAllowedExpressions\";\n\t\t\texpect(getFilterRestrictions(oMockFilterRestrictions, sMockRestrictions)).toEqual({\n\t\t\t\tSalesOrderDate: [\"AllowedExp1\", \"AllowedExp2\"],\n\t\t\t\tSoldToParty: [\"SingleValue\"]\n\t\t\t});\n\t\t});\n\t});\n\n\tdescribe(\"getNavigationRestrictions\", () => {\n\t\tit(\"no restrictions\", async () => {\n\t\t\tlet mockConverterContext: any = {\n\t\t\t\tgetEntitySet: function() {\n\t\t\t\t\treturn {};\n\t\t\t\t}\n\t\t\t};\n\t\t\tlet mockNavigationPath = \"\";\n\n\t\t\texpect(getNavigationRestrictions(mockConverterContext, mockNavigationPath)).toBeUndefined();\n\t\t});\n\n\t\tit(\"with navigation restrictions\", () => {\n\t\t\tlet mockConverterContext: any = {\n\t\t\t\tgetEntitySet: function() {\n\t\t\t\t\treturn {\n\t\t\t\t\t\tannotations: {\n\t\t\t\t\t\t\tCapabilities: {\n\t\t\t\t\t\t\t\tNavigationRestrictions: {\n\t\t\t\t\t\t\t\t\t$Type: \"Org.OData.Capabilities.V1.NavigationRestrictionsType\",\n\t\t\t\t\t\t\t\t\tfullyQualifiedName:\n\t\t\t\t\t\t\t\t\t\t\"com.c_salesordermanage_sd.EntityContainer/SalesOrderManage@Org.OData.Capabilities.V1.NavigationRestrictions\",\n\t\t\t\t\t\t\t\t\tRestrictedProperties: [\n\t\t\t\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t\t\t\t$Type: \"Org.OData.Capabilities.V1.NavigationPropertyRestriction\",\n\t\t\t\t\t\t\t\t\t\t\tNavigationProperty: {\n\t\t\t\t\t\t\t\t\t\t\t\tvalue: \"_Item\"\n\t\t\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t\t\t\t$Type: \"Org.OData.Capabilities.V1.NavigationPropertyRestriction\",\n\t\t\t\t\t\t\t\t\t\t\tNavigationProperty: {\n\t\t\t\t\t\t\t\t\t\t\t\t$NavigationPropertyPath: \"_OverallSDProcessStatus\"\n\t\t\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\t]\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t};\n\t\t\t\t}\n\t\t\t};\n\t\t\tlet mockNavigationPath = \"_Item\";\n\t\t\texpect(getNavigationRestrictions(mockConverterContext, mockNavigationPath)).toEqual({\n\t\t\t\t$Type: \"Org.OData.Capabilities.V1.NavigationPropertyRestriction\",\n\t\t\t\tNavigationProperty: {\n\t\t\t\t\tvalue: \"_Item\"\n\t\t\t\t}\n\t\t\t});\n\t\t});\n\t});\n\n\tdescribe(\"displayMode\", () => {\n\t\tit(\"no text and text arrangement annotation\", async () => {\n\t\t\tlet mockPropertyAnnotations = {\n\t\t\t\tCommon: {}\n\t\t\t};\n\t\t\tlet mockCollectionAnnotations = {};\n\t\t\texpect(displayMode(mockPropertyAnnotations, mockCollectionAnnotations)).toBe(\"Value\");\n\t\t});\n\t\tit(\"no text arrangement annotation\", async () => {\n\t\t\tlet mockPropertyAnnotations = {\n\t\t\t\tCommon: {\n\t\t\t\t\tText: {\n\t\t\t\t\t\tterm: \"com.sap.vocabularies.Common.v1.Text\",\n\t\t\t\t\t\tpath: \"_OverallSDProcessStatus/OverallSDProcessStatus_Text\"\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t};\n\t\t\tlet mockCollectionAnnotations = {};\n\t\t\texpect(displayMode(mockPropertyAnnotations, mockCollectionAnnotations)).toBe(\"DescriptionValue\");\n\t\t});\n\n\t\tit(\"with text arrangment annotation - TextOnly\", async () => {\n\t\t\tlet mockPropertyAnnotations = {\n\t\t\t\tCommon: {\n\t\t\t\t\tText: {\n\t\t\t\t\t\tannotations: {\n\t\t\t\t\t\t\tUI: {\n\t\t\t\t\t\t\t\tTextArrangement: \"UI.TextArrangementType/TextOnly\"\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t};\n\t\t\tlet mockCollectionAnnotations = {};\n\t\t\texpect(displayMode(mockPropertyAnnotations, mockCollectionAnnotations)).toBe(\"Description\");\n\t\t});\n\n\t\tit(\"with text arrangment annotation - TextLast\", async () => {\n\t\t\tlet mockPropertyAnnotations = {\n\t\t\t\tCommon: {\n\t\t\t\t\tText: {\n\t\t\t\t\t\tterm: \"com.sap.vocabularies.Common.v1.Text\",\n\t\t\t\t\t\tpath: \"_OverallSDProcessStatus/OverallSDProcessStatus_Text\"\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t};\n\t\t\tlet mockCollectionAnnotations = {\n\t\t\t\tUI: {\n\t\t\t\t\tTextArrangement: \"UI.TextArrangementType/TextLast\"\n\t\t\t\t}\n\t\t\t};\n\t\t\texpect(displayMode(mockPropertyAnnotations, mockCollectionAnnotations)).toBe(\"ValueDescription\");\n\t\t});\n\t\tit(\"with text arrangment annotation - TextFirst / Default\", async () => {\n\t\t\tlet mockPropertyAnnotations = {\n\t\t\t\tCommon: {\n\t\t\t\t\tText: {\n\t\t\t\t\t\tterm: \"com.sap.vocabularies.Common.v1.Text\",\n\t\t\t\t\t\tpath: \"_OverallSDProcessStatus/OverallSDProcessStatus_Text\"\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t};\n\t\t\tlet mockCollectionAnnotations = {\n\t\t\t\tUI: {\n\t\t\t\t\tTextArrangement: \"UI.TextArrangementType/TextFirst\"\n\t\t\t\t}\n\t\t\t};\n\t\t\texpect(displayMode(mockPropertyAnnotations, mockCollectionAnnotations)).toBe(\"DescriptionValue\");\n\t\t});\n\t});\n\n\tdescribe(\"isMultiValue\", () => {\n\t\tit(\"multivalue\", async () => {\n\t\t\tlet mockProperty = {\n\t\t\t\tfilterExpression: \"MultiRange\"\n\t\t\t};\n\t\t\texpect(isMultiValue(mockProperty)).toBeTruthy();\n\t\t});\n\n\t\tit(\"not multivalue - SearchExpression / Single Range / Single Value\", async () => {\n\t\t\tlet mockProperty = {\n\t\t\t\tfilterExpression: \"SingleRange\"\n\t\t\t};\n\t\t\texpect(isMultiValue(mockProperty)).toBeFalsy();\n\t\t});\n\n\t\tit(\"no filter expression\", async () => {\n\t\t\tlet mockProperty = {\n\t\t\t\ttype: [\"String\"]\n\t\t\t};\n\t\t\texpect(isMultiValue(mockProperty)).toBeTruthy();\n\t\t});\n\n\t\tit(\"boolean type\", async () => {\n\t\t\tlet mockProperty = {\n\t\t\t\tfilterExpression: \"SingleRange\",\n\t\t\t\ttype: [\"Boolean\"]\n\t\t\t};\n\t\t\texpect(isMultiValue(mockProperty)).toBeFalsy();\n\t\t});\n\t});\n\n\tdescribe(\"getSpecificAllowedExpression\", () => {\n\t\tit(\"get specific expression sorted on priority\", async () => {\n\t\t\tlet aExpression = [\"SearchExpression\", \"MultiValue\", \"MultiRange\"];\n\t\t\texpect(getSpecificAllowedExpression(aExpression)).toBe(\"MultiValue\");\n\t\t});\n\t});\n});\n"]}

package/packages/sap.fe.core/test/sap/fe/core/jest/controls/FilterBar.spec.ts

@@ -0,0 +1,287 @@
+import {
+	getModelType,
+	getFilterRestrictions,
+	displayMode,
+	getNavigationRestrictions,
+	isMultiValue,
+	getSpecificAllowedExpression
+} from "sap/fe/core/converters/controls/ListReport/FilterBar";
+
+describe("FilterBar", () => {
+	describe("getModelType", () => {
+		it("Boolean", async () => {
+			expect(getModelType("Edm.Boolean")).toBe("Bool");
+		});
+		it("Byte", async () => {
+			expect(getModelType("Edm.Byte")).toBe("Int");
+		});
+		it("Date", async () => {
+			expect(getModelType("Edm.Date")).toBe("Date");
+		});
+		it("String", async () => {
+			expect(getModelType("Edm.String")).toBe("String");
+		});
+	});
+
+	describe("getFilterRestrictions", () => {
+		it("no restrictions", async () => {
+			let oMockFilterRestrictions = {};
+			let sMockRestrictions = "";
+			expect(getFilterRestrictions(oMockFilterRestrictions, sMockRestrictions)).toEqual({});
+		});
+
+		it("with RequiredProperties", async () => {
+			let oMockFilterRestrictions = {
+				"RequiredProperties": [
+					{
+						name: "SalesOrder",
+						value: "SalesOrder",
+						$PropertyPath: "SalesOrder"
+					},
+					{
+						name: "SoldToParty",
+						value: "SoldToParty",
+						label: "Sold-To Party"
+					}
+				]
+			};
+			let sMockRestrictions = "RequiredProperties";
+			expect(getFilterRestrictions(oMockFilterRestrictions, sMockRestrictions)).toEqual(["SalesOrder", "SoldToParty"]);
+		});
+
+		it("with Filterableproperties", async () => {
+			let oMockFilterRestrictions = {
+				FilterExpressionRestrictions: [
+					{
+						$Type: "Org.OData.Capabilities.V1.FilterExpressionRestrictionType",
+						AllowedExpressions: "SingleValue",
+						Property: {
+							fullyQualifiedName:
+								"com.c_salesordermanage_sd.EntityContainer/SalesOrderManage@Org.OData.Capabilities.V1.FilterRestrictions/FilterExpressionRestrictions/0/Property",
+							type: "PropertyPath",
+							value: "SoldToParty"
+						}
+					},
+					{
+						$Type: "Org.OData.Capabilities.V1.FilterExpressionRestrictionType",
+						AllowedExpressions: "SingleRange",
+						Property: {
+							fullyQualifiedName:
+								"com.c_salesordermanage_sd.EntityContainer/SalesOrderManage@Org.OData.Capabilities.V1.FilterRestrictions/FilterExpressionRestrictions/1/Property",
+							type: "PropertyPath",
+							value: "SalesOrderDate"
+						}
+					}
+				]
+			};
+			let sMockRestrictions = "FilterAllowedExpressions";
+			expect(getFilterRestrictions(oMockFilterRestrictions, sMockRestrictions)).toEqual({
+				SalesOrderDate: ["SingleRange"],
+				SoldToParty: ["SingleValue"]
+			});
+		});
+
+		it("with Filterableproperties", async () => {
+			let oMockFilterRestrictions = {
+				FilterExpressionRestrictions: [
+					{
+						$Type: "Org.OData.Capabilities.V1.FilterExpressionRestrictionType",
+						AllowedExpressions: "SingleValue",
+						Property: {
+							fullyQualifiedName:
+								"com.c_salesordermanage_sd.EntityContainer/SalesOrderManage@Org.OData.Capabilities.V1.FilterRestrictions/FilterExpressionRestrictions/0/Property",
+							type: "PropertyPath",
+							value: "SoldToParty"
+						}
+					},
+					{
+						$Type: "Org.OData.Capabilities.V1.FilterExpressionRestrictionType",
+						AllowedExpressions: "AllowedExp1",
+						Property: {
+							fullyQualifiedName:
+								"com.c_salesordermanage_sd.EntityContainer/SalesOrderManage@Org.OData.Capabilities.V1.FilterRestrictions/FilterExpressionRestrictions/1/Property",
+							type: "PropertyPath",
+							value: "SalesOrderDate"
+						}
+					},
+					{
+						$Type: "Org.OData.Capabilities.V1.FilterExpressionRestrictionType",
+						AllowedExpressions: "AllowedExp2",
+						Property: {
+							fullyQualifiedName:
+								"com.c_salesordermanage_sd.EntityContainer/SalesOrderManage@Org.OData.Capabilities.V1.FilterRestrictions/FilterExpressionRestrictions/1/Property",
+							type: "PropertyPath",
+							value: "SalesOrderDate"
+						}
+					}
+				]
+			};
+			let sMockRestrictions = "FilterAllowedExpressions";
+			expect(getFilterRestrictions(oMockFilterRestrictions, sMockRestrictions)).toEqual({
+				SalesOrderDate: ["AllowedExp1", "AllowedExp2"],
+				SoldToParty: ["SingleValue"]
+			});
+		});
+	});
+
+	describe("getNavigationRestrictions", () => {
+		it("no restrictions", async () => {
+			let mockConverterContext: any = {
+				getEntitySet: function() {
+					return {};
+				}
+			};
+			let mockNavigationPath = "";
+
+			expect(getNavigationRestrictions(mockConverterContext, mockNavigationPath)).toBeUndefined();
+		});
+
+		it("with navigation restrictions", () => {
+			let mockConverterContext: any = {
+				getEntitySet: function() {
+					return {
+						annotations: {
+							Capabilities: {
+								NavigationRestrictions: {
+									$Type: "Org.OData.Capabilities.V1.NavigationRestrictionsType",
+									fullyQualifiedName:
+										"com.c_salesordermanage_sd.EntityContainer/SalesOrderManage@Org.OData.Capabilities.V1.NavigationRestrictions",
+									RestrictedProperties: [
+										{
+											$Type: "Org.OData.Capabilities.V1.NavigationPropertyRestriction",
+											NavigationProperty: {
+												value: "_Item"
+											}
+										},
+										{
+											$Type: "Org.OData.Capabilities.V1.NavigationPropertyRestriction",
+											NavigationProperty: {
+												$NavigationPropertyPath: "_OverallSDProcessStatus"
+											}
+										}
+									]
+								}
+							}
+						}
+					};
+				}
+			};
+			let mockNavigationPath = "_Item";
+			expect(getNavigationRestrictions(mockConverterContext, mockNavigationPath)).toEqual({
+				$Type: "Org.OData.Capabilities.V1.NavigationPropertyRestriction",
+				NavigationProperty: {
+					value: "_Item"
+				}
+			});
+		});
+	});
+
+	describe("displayMode", () => {
+		it("no text and text arrangement annotation", async () => {
+			let mockPropertyAnnotations = {
+				Common: {}
+			};
+			let mockCollectionAnnotations = {};
+			expect(displayMode(mockPropertyAnnotations, mockCollectionAnnotations)).toBe("Value");
+		});
+		it("no text arrangement annotation", async () => {
+			let mockPropertyAnnotations = {
+				Common: {
+					Text: {
+						term: "com.sap.vocabularies.Common.v1.Text",
+						path: "_OverallSDProcessStatus/OverallSDProcessStatus_Text"
+					}
+				}
+			};
+			let mockCollectionAnnotations = {};
+			expect(displayMode(mockPropertyAnnotations, mockCollectionAnnotations)).toBe("DescriptionValue");
+		});
+
+		it("with text arrangment annotation - TextOnly", async () => {
+			let mockPropertyAnnotations = {
+				Common: {
+					Text: {
+						annotations: {
+							UI: {
+								TextArrangement: "UI.TextArrangementType/TextOnly"
+							}
+						}
+					}
+				}
+			};
+			let mockCollectionAnnotations = {};
+			expect(displayMode(mockPropertyAnnotations, mockCollectionAnnotations)).toBe("Description");
+		});
+
+		it("with text arrangment annotation - TextLast", async () => {
+			let mockPropertyAnnotations = {
+				Common: {
+					Text: {
+						term: "com.sap.vocabularies.Common.v1.Text",
+						path: "_OverallSDProcessStatus/OverallSDProcessStatus_Text"
+					}
+				}
+			};
+			let mockCollectionAnnotations = {
+				UI: {
+					TextArrangement: "UI.TextArrangementType/TextLast"
+				}
+			};
+			expect(displayMode(mockPropertyAnnotations, mockCollectionAnnotations)).toBe("ValueDescription");
+		});
+		it("with text arrangment annotation - TextFirst / Default", async () => {
+			let mockPropertyAnnotations = {
+				Common: {
+					Text: {
+						term: "com.sap.vocabularies.Common.v1.Text",
+						path: "_OverallSDProcessStatus/OverallSDProcessStatus_Text"
+					}
+				}
+			};
+			let mockCollectionAnnotations = {
+				UI: {
+					TextArrangement: "UI.TextArrangementType/TextFirst"
+				}
+			};
+			expect(displayMode(mockPropertyAnnotations, mockCollectionAnnotations)).toBe("DescriptionValue");
+		});
+	});
+
+	describe("isMultiValue", () => {
+		it("multivalue", async () => {
+			let mockProperty = {
+				filterExpression: "MultiRange"
+			};
+			expect(isMultiValue(mockProperty)).toBeTruthy();
+		});
+
+		it("not multivalue - SearchExpression / Single Range / Single Value", async () => {
+			let mockProperty = {
+				filterExpression: "SingleRange"
+			};
+			expect(isMultiValue(mockProperty)).toBeFalsy();
+		});
+
+		it("no filter expression", async () => {
+			let mockProperty = {
+				type: ["String"]
+			};
+			expect(isMultiValue(mockProperty)).toBeTruthy();
+		});
+
+		it("boolean type", async () => {
+			let mockProperty = {
+				filterExpression: "SingleRange",
+				type: ["Boolean"]
+			};
+			expect(isMultiValue(mockProperty)).toBeFalsy();
+		});
+	});
+
+	describe("getSpecificAllowedExpression", () => {
+		it("get specific expression sorted on priority", async () => {
+			let aExpression = ["SearchExpression", "MultiValue", "MultiRange"];
+			expect(getSpecificAllowedExpression(aExpression)).toBe("MultiValue");
+		});
+	});
+});