public void Init() { EdmModel model = new EdmModel(); EdmComplexType complex1 = new EdmComplexType("ns", "complex1"); complex1.AddProperty(new EdmStructuralProperty(complex1, "p1", EdmCoreModel.Instance.GetInt32(isNullable: false))); model.AddElement(complex1); EdmComplexType complex2 = new EdmComplexType("ns", "complex2"); complex2.AddProperty(new EdmStructuralProperty(complex2, "p1", EdmCoreModel.Instance.GetInt32(isNullable: false))); model.AddElement(complex2); EdmComplexTypeReference complex2Reference = new EdmComplexTypeReference(complex2, isNullable: false); EdmCollectionType primitiveCollectionType = new EdmCollectionType(EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Int32, isNullable: false)); EdmCollectionType complexCollectionType = new EdmCollectionType(complex2Reference); EdmCollectionTypeReference primitiveCollectionTypeReference = new EdmCollectionTypeReference(primitiveCollectionType); EdmCollectionTypeReference complexCollectionTypeReference = new EdmCollectionTypeReference(complexCollectionType); model.AddElement(new EdmTerm("custom", "int", EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Int32, isNullable: false))); model.AddElement(new EdmTerm("custom", "string", EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.String, isNullable: false))); model.AddElement(new EdmTerm("custom", "double", EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Double, isNullable: false))); model.AddElement(new EdmTerm("custom", "bool", EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Boolean, isNullable: true))); model.AddElement(new EdmTerm("custom", "decimal", EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Decimal, isNullable: false))); model.AddElement(new EdmTerm("custom", "timespan", EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Duration, isNullable: false))); model.AddElement(new EdmTerm("custom", "guid", EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Guid, isNullable: false))); model.AddElement(new EdmTerm("custom", "complex", complex2Reference)); model.AddElement(new EdmTerm("custom", "primitiveCollection", primitiveCollectionTypeReference)); model.AddElement(new EdmTerm("custom", "complexCollection", complexCollectionTypeReference)); this.stream = new MemoryStream(); this.settings = new ODataMessageWriterSettings { Version = ODataVersion.V4, ShouldIncludeAnnotation = ODataUtils.CreateAnnotationFilter("*") }; this.settings.SetServiceDocumentUri(ServiceDocumentUri); this.serializer = new ODataAtomPropertyAndValueSerializer(this.CreateAtomOutputContext(model, this.stream)); }
public void FindAction_CannotFind_BindableAction_DerivedEntityCollection() { // Arrange var entityCollection = new EdmCollectionType(_entityType); // Act & Assert Assert.Null(_model.FindAction("NS.ActionBoundToDerivedEntityCollection", entityCollection)); }
public void CollectionType_IsDeltaFeed_ReturnsFalseForNonDeltaCollectionType() { IEdmEntityType _entityType = new EdmEntityType("NS", "Entity"); EdmCollectionType _edmType = new EdmCollectionType(new EdmEntityTypeReference(_entityType, isNullable: true)); IEdmCollectionTypeReference _edmTypeReference = new EdmCollectionTypeReference(_edmType); Assert.False(_edmTypeReference.Definition.IsDeltaFeed()); }
public void FindAction_CannotFind_BindableAction_DerivedEntityCollection() { // Arrange var entityCollection = new EdmCollectionType(_entityType); IEdmEntityContainer container = GetEntityContainer(); // Act & Assert Assert.Null(container.FindAction("ActionBoundToDerivedEntityCollection", bindingParameterType: entityCollection)); }
public void CalculateBindableOperationsForEntityCollectionTypeWithoutTypeResolver() { var bindingType = new EdmCollectionType(this.model.FindType("TestModel.Movie").ToTypeReference(nullable:false)); var bindableOperations = MetadataUtils.CalculateBindableOperationsForType(bindingType, this.model, new EdmTypeReaderResolver(this.model, ODataReaderBehavior.DefaultBehavior)); Assert.AreEqual(2, bindableOperations.Length); foreach (var operation in bindableOperations) { Assert.AreEqual("RateMultiple", operation.Name); } }
public ODataJsonLightReaderEnumIntegrationTests() { EdmModel tmpModel = new EdmModel(); // enum without flags var enumType = new EdmEnumType("NS", "Color"); var red = new EdmEnumMember(enumType, "Red", new EdmIntegerConstant(1)); enumType.AddMember(red); enumType.AddMember("Green", new EdmIntegerConstant(2)); enumType.AddMember("Blue", new EdmIntegerConstant(3)); tmpModel.AddElement(enumType); // enum with flags var enumFlagsType = new EdmEnumType("NS", "ColorFlags", isFlags: true); enumFlagsType.AddMember("Red", new EdmIntegerConstant(1)); enumFlagsType.AddMember("Green", new EdmIntegerConstant(2)); enumFlagsType.AddMember("Blue", new EdmIntegerConstant(4)); tmpModel.AddElement(enumFlagsType); this.entityType = new EdmEntityType("NS", "MyEntityType", isAbstract: false, isOpen: true, baseType: null); EdmStructuralProperty floatId = new EdmStructuralProperty(this.entityType, "FloatId", EdmCoreModel.Instance.GetSingle(false)); this.entityType.AddKeys(floatId); this.entityType.AddProperty(floatId); var enumTypeReference = new EdmEnumTypeReference(enumType, true); this.entityType.AddProperty(new EdmStructuralProperty(this.entityType, "Color", enumTypeReference)); var enumFlagsTypeReference = new EdmEnumTypeReference(enumFlagsType, false); this.entityType.AddProperty(new EdmStructuralProperty(this.entityType, "ColorFlags", enumFlagsTypeReference)); // enum in complex type EdmComplexType myComplexType = new EdmComplexType("NS", "MyComplexType"); myComplexType.AddProperty(new EdmStructuralProperty(myComplexType, "MyColorFlags", enumFlagsTypeReference)); myComplexType.AddProperty(new EdmStructuralProperty(myComplexType, "Height", EdmCoreModel.Instance.GetDouble(false))); tmpModel.AddElement(myComplexType); this.entityType.AddProperty(new EdmStructuralProperty(this.entityType, "MyComplexType", new EdmComplexTypeReference(myComplexType, true))); // enum in derived complex type EdmComplexType myDerivedComplexType = new EdmComplexType("NS", "MyDerivedComplexType", myComplexType, false); myDerivedComplexType.AddProperty(new EdmStructuralProperty(myDerivedComplexType, "MyDerivedColorFlags", new EdmEnumTypeReference(enumFlagsType, false))); tmpModel.AddElement(myDerivedComplexType); // enum in collection type EdmCollectionType myCollectionType = new EdmCollectionType(enumFlagsTypeReference); this.entityType.AddProperty(new EdmStructuralProperty(this.entityType, "MyCollectionType", new EdmCollectionTypeReference(myCollectionType))); tmpModel.AddElement(this.entityType); var defaultContainer = new EdmEntityContainer("NS", "DefaultContainer_sub"); this.entitySet = new EdmEntitySet(defaultContainer, "MySet", this.entityType); defaultContainer.AddEntitySet(this.entitySet.Name, this.entityType); tmpModel.AddElement(defaultContainer); this.userModel = TestUtils.WrapReferencedModelsToMainModel("NS", "DefaultContainer", tmpModel); }
public void FindAction_CanFind_BindableAction_EntityCollection(string segment, bool isDerivedType) { // Arrange IEdmTypeReference entityType = isDerivedType ? _derivedEntityType : _entityType; var entityCollection = new EdmCollectionType(entityType); // Act var result = _model.FindAction(segment, entityCollection); // Assert Assert.NotNull(result); Assert.Equal("NS.ActionBoundToEntityCollection", result.FullName()); }
public void GetEdmType_ReturnsCollectionCastType_IfPreviousTypeIsCollection() { // Arrange EdmEntityType castType = new EdmEntityType("NS", "Entity"); EdmCollectionType previousEdmType = new EdmCollectionType(new EdmEntityType("NS", "PreviousType").AsReference()); CastPathSegment castSegment = new CastPathSegment(castType); // Act var result = castSegment.GetEdmType(previousEdmType); // Assert Assert.Equal(EdmTypeKind.Collection, result.TypeKind); Assert.Equal(castType, (result as IEdmCollectionType).ElementType.Definition); }
public void FindAction_CanFind_BindableAction_EntityCollection(string segment, bool isDerivedType) { // Arrange IEdmTypeReference entityType = isDerivedType ? _derivedEntityType : _entityType; var entityCollection = new EdmCollectionType(entityType); IEdmEntityContainer container = GetEntityContainer(); // Act var result = container.FindAction(segment, bindingParameterType: entityCollection); // Assert Assert.NotNull(result); Assert.Equal("NS.Name.ActionBoundToEntityCollection", result.Container.FullName() + "." + result.Name); }
public ODataAtomAnnotationReaderTests() { this.model = new EdmModel(); this.model.AddElement(new EdmComplexType("foo", "complex")); EdmComplexType complexType = new EdmComplexType("ns", "complex"); this.model.AddElement(complexType); EdmComplexTypeReference complexTypeReference = new EdmComplexTypeReference(complexType, isNullable: false); EdmCollectionType primitiveCollectionType = new EdmCollectionType(EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Guid, isNullable: false)); EdmCollectionType complexCollectionType = new EdmCollectionType(complexTypeReference); EdmCollectionTypeReference primitiveCollectionTypeReference = new EdmCollectionTypeReference(primitiveCollectionType); EdmCollectionTypeReference complexCollectionTypeReference = new EdmCollectionTypeReference(complexCollectionType); this.model.AddElement(new EdmTerm("custom", "primitive", EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Double, isNullable: false))); this.model.AddElement(new EdmTerm("custom", "complex", complexTypeReference)); this.model.AddElement(new EdmTerm("custom", "primitiveCollection", primitiveCollectionTypeReference)); this.model.AddElement(new EdmTerm("custom", "complexCollection", complexCollectionTypeReference)); this.shouldIncludeAnnotation = (annotationName) => true; }
public ODataAtomWriterEnumIntegrationTests() { this.userModel = new EdmModel(); var enumType = new EdmEnumType("NS", "Color"); var red = new EdmEnumMember(enumType, "Red", new EdmIntegerConstant(1)); enumType.AddMember(red); enumType.AddMember("Green", new EdmIntegerConstant(2)); enumType.AddMember("Blue", new EdmIntegerConstant(3)); // enum with flags var enumFlagsType = new EdmEnumType("NS", "ColorFlags", isFlags: true); enumFlagsType.AddMember("Red", new EdmIntegerConstant(1)); enumFlagsType.AddMember("Green", new EdmIntegerConstant(2)); enumFlagsType.AddMember("Blue", new EdmIntegerConstant(4)); this.entityType = new EdmEntityType("NS", "MyEntityType", isAbstract: false, isOpen: true, baseType: null); this.entityType.AddKeys(new EdmStructuralProperty(this.entityType, "FloatId", EdmCoreModel.Instance.GetDouble(false))); var enumTypeReference = new EdmEnumTypeReference(enumType, true); this.entityType.AddProperty(new EdmStructuralProperty(this.entityType, "Color", enumTypeReference)); // add enum with flags var enumFlagsTypeReference = new EdmEnumTypeReference(enumFlagsType, false); this.entityType.AddProperty(new EdmStructuralProperty(this.entityType, "ColorFlags", enumFlagsTypeReference)); // enum in complex type EdmComplexType myComplexType = new EdmComplexType("NS", "MyComplexType"); myComplexType.AddProperty(new EdmStructuralProperty(myComplexType, "MyColorFlags", enumFlagsTypeReference)); myComplexType.AddProperty(new EdmStructuralProperty(myComplexType, "Height", EdmCoreModel.Instance.GetDouble(false))); this.entityType.AddProperty(new EdmStructuralProperty(this.entityType, "MyComplexType", new EdmComplexTypeReference(myComplexType, true))); // enum in collection type EdmCollectionType myCollectionType = new EdmCollectionType(enumFlagsTypeReference); this.entityType.AddProperty(new EdmStructuralProperty(this.entityType, "MyCollectionType", new EdmCollectionTypeReference(myCollectionType))); this.userModel.AddElement(this.entityType); var defaultContainer = new EdmEntityContainer("NS", "DefaultContainer"); this.userModel.AddElement(defaultContainer); this.entitySet = new EdmEntitySet(defaultContainer, "MySet", this.entityType); }
public CustomersModelWithInheritance() { EdmModel model = new EdmModel(); // Enum type simpleEnum EdmEnumType simpleEnum = new EdmEnumType("NS", "SimpleEnum"); simpleEnum.AddMember(new EdmEnumMember(simpleEnum, "First", new EdmIntegerConstant(0))); simpleEnum.AddMember(new EdmEnumMember(simpleEnum, "Second", new EdmIntegerConstant(1))); simpleEnum.AddMember(new EdmEnumMember(simpleEnum, "Third", new EdmIntegerConstant(2))); model.AddElement(simpleEnum); // complex type address EdmComplexType address = new EdmComplexType("NS", "Address"); address.AddStructuralProperty("Street", EdmPrimitiveTypeKind.String); address.AddStructuralProperty("City", EdmPrimitiveTypeKind.String); address.AddStructuralProperty("State", EdmPrimitiveTypeKind.String); address.AddStructuralProperty("ZipCode", EdmPrimitiveTypeKind.String); address.AddStructuralProperty("Country", EdmPrimitiveTypeKind.String); model.AddElement(address); // open complex type "Account" EdmComplexType account = new EdmComplexType("NS", "Account", null, false, true); account.AddStructuralProperty("Bank", EdmPrimitiveTypeKind.String); account.AddStructuralProperty("CardNum", EdmPrimitiveTypeKind.Int64); model.AddElement(account); EdmComplexType specialAccount = new EdmComplexType("NS", "SpecialAccount", account, false, true); specialAccount.AddStructuralProperty("SpecialCard", EdmPrimitiveTypeKind.String); model.AddElement(specialAccount); // entity type customer EdmEntityType customer = new EdmEntityType("NS", "Customer"); customer.AddKeys(customer.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32)); IEdmProperty customerName = customer.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String); customer.AddStructuralProperty("SimpleEnum", simpleEnum.ToEdmTypeReference(isNullable: false)); customer.AddStructuralProperty("Address", new EdmComplexTypeReference(address, isNullable: true)); customer.AddStructuralProperty("Account", new EdmComplexTypeReference(account, isNullable: true)); IEdmTypeReference primitiveTypeReference = EdmCoreModel.Instance.GetPrimitive( EdmPrimitiveTypeKind.String, isNullable: true); var city = customer.AddStructuralProperty( "City", primitiveTypeReference, defaultValue: null, concurrencyMode: EdmConcurrencyMode.Fixed); model.AddElement(customer); // derived entity type special customer EdmEntityType specialCustomer = new EdmEntityType("NS", "SpecialCustomer", customer); specialCustomer.AddStructuralProperty("SpecialCustomerProperty", EdmPrimitiveTypeKind.Guid); specialCustomer.AddStructuralProperty("SpecialAddress", new EdmComplexTypeReference(address, isNullable: true)); model.AddElement(specialCustomer); // entity type order (open entity type) EdmEntityType order = new EdmEntityType("NS", "Order", null, false, true); // EdmEntityType order = new EdmEntityType("NS", "Order"); order.AddKeys(order.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32)); order.AddStructuralProperty("City", EdmPrimitiveTypeKind.String); order.AddStructuralProperty("Amount", EdmPrimitiveTypeKind.Int32); model.AddElement(order); // derived entity type special order EdmEntityType specialOrder = new EdmEntityType("NS", "SpecialOrder", order, false, true); specialOrder.AddStructuralProperty("SpecialOrderProperty", EdmPrimitiveTypeKind.Guid); model.AddElement(specialOrder); // test entity EdmEntityType testEntity = new EdmEntityType("System.Web.OData.Query.Expressions", "TestEntity"); testEntity.AddStructuralProperty("SampleProperty", EdmPrimitiveTypeKind.Binary); model.AddElement(testEntity); // containment // my order EdmEntityType myOrder = new EdmEntityType("NS", "MyOrder"); myOrder.AddKeys(myOrder.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32)); myOrder.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String); model.AddElement(myOrder); // order line EdmEntityType orderLine = new EdmEntityType("NS", "OrderLine"); orderLine.AddKeys(orderLine.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32)); orderLine.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String); model.AddElement(orderLine); EdmNavigationProperty orderLinesNavProp = myOrder.AddUnidirectionalNavigation( new EdmNavigationPropertyInfo { Name = "OrderLines", TargetMultiplicity = EdmMultiplicity.Many, Target = orderLine, ContainsTarget = true, }); EdmNavigationProperty nonContainedOrderLinesNavProp = myOrder.AddUnidirectionalNavigation( new EdmNavigationPropertyInfo { Name = "NonContainedOrderLines", TargetMultiplicity = EdmMultiplicity.Many, Target = orderLine, ContainsTarget = false, }); EdmAction tag = new EdmAction("NS", "tag", returnType: null, isBound: true, entitySetPathExpression: null); tag.AddParameter("entity", new EdmEntityTypeReference(orderLine, false)); model.AddElement(tag); // entity sets EdmEntityContainer container = new EdmEntityContainer("NS", "ModelWithInheritance"); model.AddElement(container); EdmEntitySet customers = container.AddEntitySet("Customers", customer); EdmEntitySet orders = container.AddEntitySet("Orders", order); EdmEntitySet myOrders = container.AddEntitySet("MyOrders", myOrder); // singletons EdmSingleton vipCustomer = container.AddSingleton("VipCustomer", customer); EdmSingleton mary = container.AddSingleton("Mary", customer); EdmSingleton rootOrder = container.AddSingleton("RootOrder", order); // annotations model.SetOptimisticConcurrencyAnnotation(customers, new[] { city }); // containment IEdmContainedEntitySet orderLines = (IEdmContainedEntitySet)myOrders.FindNavigationTarget(orderLinesNavProp); // no-containment IEdmNavigationSource nonContainedOrderLines = myOrders.FindNavigationTarget(nonContainedOrderLinesNavProp); // actions EdmAction upgrade = new EdmAction("NS", "upgrade", returnType: null, isBound: true, entitySetPathExpression: null); upgrade.AddParameter("entity", new EdmEntityTypeReference(customer, false)); model.AddElement(upgrade); EdmAction specialUpgrade = new EdmAction("NS", "specialUpgrade", returnType: null, isBound: true, entitySetPathExpression: null); specialUpgrade.AddParameter("entity", new EdmEntityTypeReference(specialCustomer, false)); model.AddElement(specialUpgrade); // actions bound to collection EdmAction upgradeAll = new EdmAction("NS", "UpgradeAll", returnType: null, isBound: true, entitySetPathExpression: null); upgradeAll.AddParameter("entityset", new EdmCollectionTypeReference(new EdmCollectionType(new EdmEntityTypeReference(customer, false)))); model.AddElement(upgradeAll); EdmAction upgradeSpecialAll = new EdmAction("NS", "UpgradeSpecialAll", returnType: null, isBound: true, entitySetPathExpression: null); upgradeSpecialAll.AddParameter("entityset", new EdmCollectionTypeReference(new EdmCollectionType(new EdmEntityTypeReference(specialCustomer, false)))); model.AddElement(upgradeSpecialAll); // functions IEdmTypeReference returnType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Boolean, isNullable: false); IEdmTypeReference stringType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.String, isNullable: false); IEdmTypeReference intType = EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.Int32, isNullable: false); EdmFunction IsUpgraded = new EdmFunction( "NS", "IsUpgraded", returnType, isBound: true, entitySetPathExpression: null, isComposable: false); IsUpgraded.AddParameter("entity", new EdmEntityTypeReference(customer, false)); model.AddElement(IsUpgraded); EdmFunction orderByCityAndAmount = new EdmFunction( "NS", "OrderByCityAndAmount", stringType, isBound: true, entitySetPathExpression: null, isComposable: false); orderByCityAndAmount.AddParameter("entity", new EdmEntityTypeReference(customer, false)); orderByCityAndAmount.AddParameter("city", stringType); orderByCityAndAmount.AddParameter("amount", intType); model.AddElement(orderByCityAndAmount); EdmFunction getOrders = new EdmFunction( "NS", "GetOrders", EdmCoreModel.GetCollection(order.ToEdmTypeReference(false)), isBound: true, entitySetPathExpression: null, isComposable: true); getOrders.AddParameter("entity", new EdmEntityTypeReference(customer, false)); getOrders.AddParameter("parameter", intType); model.AddElement(getOrders); EdmFunction IsSpecialUpgraded = new EdmFunction( "NS", "IsSpecialUpgraded", returnType, isBound: true, entitySetPathExpression: null, isComposable: false); IsSpecialUpgraded.AddParameter("entity", new EdmEntityTypeReference(specialCustomer, false)); model.AddElement(IsSpecialUpgraded); EdmFunction getSalary = new EdmFunction( "NS", "GetSalary", stringType, isBound: true, entitySetPathExpression: null, isComposable: false); getSalary.AddParameter("entity", new EdmEntityTypeReference(customer, false)); model.AddElement(getSalary); getSalary = new EdmFunction( "NS", "GetSalary", stringType, isBound: true, entitySetPathExpression: null, isComposable: false); getSalary.AddParameter("entity", new EdmEntityTypeReference(specialCustomer, false)); model.AddElement(getSalary); EdmFunction IsAnyUpgraded = new EdmFunction( "NS", "IsAnyUpgraded", returnType, isBound: true, entitySetPathExpression: null, isComposable: false); EdmCollectionType edmCollectionType = new EdmCollectionType(new EdmEntityTypeReference(customer, false)); IsAnyUpgraded.AddParameter("entityset", new EdmCollectionTypeReference(edmCollectionType)); model.AddElement(IsAnyUpgraded); EdmFunction isCustomerUpgradedWithParam = new EdmFunction( "NS", "IsUpgradedWithParam", returnType, isBound: true, entitySetPathExpression: null, isComposable: false); isCustomerUpgradedWithParam.AddParameter("entity", new EdmEntityTypeReference(customer, false)); isCustomerUpgradedWithParam.AddParameter("city", EdmCoreModel.Instance.GetPrimitive(EdmPrimitiveTypeKind.String, isNullable: false)); model.AddElement(isCustomerUpgradedWithParam); EdmFunction isCustomerLocal = new EdmFunction( "NS", "IsLocal", returnType, isBound: true, entitySetPathExpression: null, isComposable: false); isCustomerLocal.AddParameter("entity", new EdmEntityTypeReference(customer, false)); model.AddElement(isCustomerLocal); EdmFunction entityFunction = new EdmFunction( "NS", "GetCustomer", returnType, isBound: true, entitySetPathExpression: null, isComposable: false); entityFunction.AddParameter("entity", new EdmEntityTypeReference(customer, false)); entityFunction.AddParameter("customer", new EdmEntityTypeReference(customer, false)); model.AddElement(entityFunction); EdmFunction getOrder = new EdmFunction( "NS", "GetOrder", order.ToEdmTypeReference(false), isBound: true, entitySetPathExpression: null, isComposable: true); // Composable getOrder.AddParameter("entity", new EdmEntityTypeReference(customer, false)); getOrder.AddParameter("orderId", intType); model.AddElement(getOrder); // functions bound to collection EdmFunction isAllUpgraded = new EdmFunction("NS", "IsAllUpgraded", returnType, isBound: true, entitySetPathExpression: null, isComposable: false); isAllUpgraded.AddParameter("entityset", new EdmCollectionTypeReference(new EdmCollectionType(new EdmEntityTypeReference(customer, false)))); isAllUpgraded.AddParameter("param", intType); model.AddElement(isAllUpgraded); EdmFunction isSpecialAllUpgraded = new EdmFunction("NS", "IsSpecialAllUpgraded", returnType, isBound: true, entitySetPathExpression: null, isComposable: false); isSpecialAllUpgraded.AddParameter("entityset", new EdmCollectionTypeReference(new EdmCollectionType(new EdmEntityTypeReference(specialCustomer, false)))); isSpecialAllUpgraded.AddParameter("param", intType); model.AddElement(isSpecialAllUpgraded); // navigation properties EdmNavigationProperty ordersNavProp = customer.AddUnidirectionalNavigation( new EdmNavigationPropertyInfo { Name = "Orders", TargetMultiplicity = EdmMultiplicity.Many, Target = order }); mary.AddNavigationTarget(ordersNavProp, orders); vipCustomer.AddNavigationTarget(ordersNavProp, orders); customers.AddNavigationTarget(ordersNavProp, orders); orders.AddNavigationTarget( order.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo { Name = "Customer", TargetMultiplicity = EdmMultiplicity.ZeroOrOne, Target = customer }), customers); // navigation properties on derived types. EdmNavigationProperty specialOrdersNavProp = specialCustomer.AddUnidirectionalNavigation( new EdmNavigationPropertyInfo { Name = "SpecialOrders", TargetMultiplicity = EdmMultiplicity.Many, Target = order }); vipCustomer.AddNavigationTarget(specialOrdersNavProp, orders); customers.AddNavigationTarget(specialOrdersNavProp, orders); orders.AddNavigationTarget( specialOrder.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo { Name = "SpecialCustomer", TargetMultiplicity = EdmMultiplicity.ZeroOrOne, Target = customer }), customers); model.SetAnnotationValue<BindableProcedureFinder>(model, new BindableProcedureFinder(model)); // set properties Model = model; Container = container; Customer = customer; Order = order; Address = address; Account = account; SpecialCustomer = specialCustomer; SpecialOrder = specialOrder; Orders = orders; Customers = customers; VipCustomer = vipCustomer; Mary = mary; RootOrder = rootOrder; OrderLine = orderLine; OrderLines = orderLines; NonContainedOrderLines = nonContainedOrderLines; UpgradeCustomer = upgrade; UpgradeSpecialCustomer = specialUpgrade; CustomerName = customerName; IsCustomerUpgraded = isCustomerUpgradedWithParam; IsSpecialCustomerUpgraded = IsSpecialUpgraded; Tag = tag; }
/// <summary> /// Creates a collection value type for the specified <paramref name="itemTypeReference"/>. /// </summary> /// <param name="itemTypeReference">The <see cref="IEdmPrimitiveTypeReference"/> for the item type.</param> /// <returns>The created <see cref="IEdmCollectionTypeReference"/>.</returns> public static IEdmCollectionTypeReference ToCollectionTypeReference(this IEdmPrimitiveTypeReference itemTypeReference) { IEdmCollectionType collectionType = new EdmCollectionType(itemTypeReference); return (IEdmCollectionTypeReference)ToTypeReference(collectionType); }
public void NonPrimitiveAsXXXMethods() { IEdmPrimitiveType intDef = EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.Int32); IEdmPrimitiveTypeReference intRef = new EdmPrimitiveTypeReference(intDef, false); IEdmEntityType entityDef = new EdmEntityType("MyNamespace", "MyEntity"); IEdmEntityTypeReference entityRef = new EdmEntityTypeReference(entityDef, false); IEdmComplexType complexDef = new EdmComplexType("MyNamespace", "MyComplex"); IEdmComplexTypeReference complexRef = new EdmComplexTypeReference(complexDef, false); IEdmCollectionType collectionDef = new EdmCollectionType(intRef); IEdmCollectionTypeReference collectionRef = new EdmCollectionTypeReference(collectionDef); IEdmCollectionTypeReference badCollectionRef = entityRef.AsCollection(); IEdmEntityTypeReference badEntityRef = collectionRef.AsEntity(); IEdmComplexTypeReference badComplexRef = entityRef.AsComplex(); IEdmEntityReferenceTypeReference badEntityRefRef= entityRef.AsEntityReference(); Assert.IsTrue(badCollectionRef.IsBad(), "Bad Collection is bad"); Assert.AreEqual(EdmErrorCode.TypeSemanticsCouldNotConvertTypeReference, badCollectionRef.Errors().First().ErrorCode, "Reference is bad from conversion"); Assert.AreEqual("[Collection([UnknownType Nullable=True]) Nullable=True]", badCollectionRef.ToString(), "Correct tostring"); Assert.IsTrue(badComplexRef.IsBad(), "Bad Complex is Bad"); Assert.IsTrue(badComplexRef.Definition.IsBad(), "Bad Complex definition is Bad"); Assert.AreEqual(EdmErrorCode.TypeSemanticsCouldNotConvertTypeReference, badComplexRef.Definition.Errors().First().ErrorCode, "Reference is bad from conversion"); Assert.AreEqual("TypeSemanticsCouldNotConvertTypeReference:[MyNamespace.MyEntity Nullable=False]", badComplexRef.ToString(), "Correct tostring"); Assert.IsTrue(badEntityRef.IsBad(), "Bad Entity is bad"); Assert.IsTrue(badEntityRef.Definition.IsBad(), "Bad Entity Definition is bad"); Assert.AreEqual(EdmErrorCode.TypeSemanticsCouldNotConvertTypeReference, badEntityRef.Definition.Errors().First().ErrorCode, "Reference is bad from conversion"); Assert.AreEqual("TypeSemanticsCouldNotConvertTypeReference:[Collection(Edm.Int32) Nullable=False]", badEntityRef.ToString(), "Correct tostring"); Assert.IsTrue(badEntityRefRef.IsBad(), "Bad Entity Reference is Bad"); Assert.AreEqual(EdmErrorCode.TypeSemanticsCouldNotConvertTypeReference, badEntityRefRef.Errors().First().ErrorCode, "Reference is bad from conversion"); Assert.AreEqual("[EntityReference(.) Nullable=False]", badEntityRefRef.ToString(), "Correct tostring"); Assert.IsFalse(entityRef.AsEntity().IsBad(), "Entity converted to Entity is good"); Assert.IsFalse(complexRef.AsComplex().IsBad(), "Complex converted to complex is good"); Assert.IsFalse(collectionRef.AsCollection().IsBad(), "Collection converted to collection is good"); Assert.IsTrue(entityRef.AsStructured().IsEntity(), "Entity as structured is entity"); Assert.IsFalse(entityRef.AsStructured().IsBad(), "Entity as structured is good"); Assert.IsTrue(complexRef.AsStructured().IsComplex(), "Complex as structured is complex"); Assert.IsFalse(complexRef.AsStructured().IsBad(), "Complex as structured is good"); Assert.IsFalse(collectionRef.AsStructured().IsCollection(), "Collection as structured is not collection"); Assert.IsTrue(collectionRef.AsStructured().IsBad(), "Collection as structured is bad"); Assert.IsTrue(collectionRef.AsStructured().Definition.IsBad(), "Collection as structured definition is bad"); Assert.AreEqual(EdmErrorCode.TypeSemanticsCouldNotConvertTypeReference, collectionRef.AsStructured().Definition.Errors().First().ErrorCode, "Reference is bad from conversion"); }
public void EqualityCollectionTypeTest() { var baselineCollectionTypeElement = new EdmEntityType("NS", "Baseline", new EdmEntityType("NS", "foo", null, true, false), true, false); var differentCollectionTypeElement = new EdmEntityType("NS", "Baseline", new EdmEntityType("NS", "bar", null, false, false), true, false); var baseline = new EdmCollectionType(new EdmEntityTypeReference(baselineCollectionTypeElement, true)); var match = new EdmCollectionType(new EdmEntityTypeReference(baselineCollectionTypeElement, true)); var differentCollectionNullibility = new EdmCollectionType(new EdmEntityTypeReference(baselineCollectionTypeElement, false)); var differentCollectionType = new EdmCollectionType(new EdmEntityTypeReference(differentCollectionTypeElement, true)); Assert.IsTrue(baseline.IsEquivalentTo(match), "Is the same."); Assert.IsFalse(baseline.IsEquivalentTo(differentCollectionNullibility), "Different nullibility."); Assert.IsFalse(baseline.IsEquivalentTo(differentCollectionType), "Different collection type element (different obj refs)."); differentCollectionType = new EdmCollectionType(new EdmEntityTypeReference(baselineCollectionTypeElement, true)); Assert.IsTrue(baseline.IsEquivalentTo(differentCollectionType), "Different collection types equal on element."); }
public void ShortQualifiedNameForCollectionOfNonPrimitiveTypeShouldBeCollectionOfFullName() { const string stringOfNamespaceName = "TestModel"; const string stringOfComplexTypeName = "MyComplexType"; var edmComplexType = new EdmComplexType(stringOfNamespaceName, stringOfComplexTypeName); var edmCollectionType = new EdmCollectionType(new EdmComplexTypeReference(edmComplexType, true)); var stringOfExpectedShortQulifiedName = String.Format("Collection({0}.{1})", stringOfNamespaceName, stringOfComplexTypeName); var stringOfObservedShortQulifiedName = edmCollectionType.ODataShortQualifiedName(); stringOfObservedShortQulifiedName.Should().Be(stringOfExpectedShortQulifiedName); const string stringEntityTypeName = "MyEntityType"; var edmEntityType = new EdmEntityType(stringOfNamespaceName, stringEntityTypeName); edmCollectionType = new EdmCollectionType(new EdmEntityTypeReference(edmEntityType, true)); stringOfExpectedShortQulifiedName = String.Format("Collection({0}.{1})", stringOfNamespaceName, stringEntityTypeName); stringOfObservedShortQulifiedName = edmCollectionType.ODataShortQualifiedName(); stringOfObservedShortQulifiedName.Should().Be(stringOfExpectedShortQulifiedName); }
public void ShortQualifiedNameForCollectionPrimitiveTypeShouldBeCollectionOfName() { foreach (EdmPrimitiveTypeKind edmPrimitiveTypeKind in Enum.GetValues(typeof(EdmPrimitiveTypeKind))) { if (EdmPrimitiveTypeKind.None == edmPrimitiveTypeKind) continue; var stringOfName = Enum.GetName(typeof(EdmPrimitiveTypeKind), edmPrimitiveTypeKind); stringOfName.ToUpper().Should().NotContain("EDM."); var stringOfExpectedShortQulifiedName = String.Format("Collection({0})", stringOfName); var iEdmPrimitiveType = EdmCoreModel.Instance.GetPrimitiveType(edmPrimitiveTypeKind); var edmCollectionType=new EdmCollectionType(new EdmPrimitiveTypeReference(iEdmPrimitiveType,true)); var stringOfObservedShortQulifiedName = edmCollectionType.ODataShortQualifiedName(); stringOfObservedShortQulifiedName.Should().Be(stringOfExpectedShortQulifiedName); } }
public void FindMatchedOperations_CannotFind_BindableFunction_DerivedEntityCollection() { // Arrange var entityCollection = new EdmCollectionType(_entityType); // Act & Assert Assert.Empty(_model.FindMatchedOperations("NS.FunctionBoundToDerivedEntityCollection", entityCollection)); }
public void FindMatchedOperations_DoesNotReturnNonBindableFunction_IfBindingParameterSpecified() { // Arrange var entityCollection = new EdmCollectionType(_entityType); // Act & Assert Assert.Empty(_model.FindMatchedOperations("NS.NonBindableAction", entityCollection)); Assert.Empty(_model.FindMatchedOperations("NS.NonBindableAction", _entityType.Definition)); }
private bool TryCreateTypeNameSegment(ODataPathSegment previous, string identifier, string parenthesisExpression) { IEdmType targetEdmType; if (previous.TargetEdmType == null || (targetEdmType = UriEdmHelpers.FindTypeFromModel(this.configuration.Model, identifier, this.configuration.Resolver)) == null) { return false; } // if the new type segment prevents any results from possibly being returned, then short-circuit and throw a 404. IEdmType previousEdmType = previous.TargetEdmType; Debug.Assert(previousEdmType != null, "previous.TargetEdmType != null"); if (previousEdmType.TypeKind == EdmTypeKind.Collection) { previousEdmType = ((IEdmCollectionType)previousEdmType).ElementType.Definition; } if (!targetEdmType.IsOrInheritsFrom(previousEdmType) && !previousEdmType.IsOrInheritsFrom(targetEdmType)) { throw ExceptionUtil.CreateBadRequestError(ODataErrorStrings.RequestUriProcessor_InvalidTypeIdentifier_UnrelatedType(targetEdmType.ODataFullName(), previousEdmType.ODataFullName())); } // We want the type of the type segment to be a collection if the previous segment was a collection IEdmType actualTypeOfTheTypeSegment = targetEdmType; if (previous.EdmType.TypeKind == EdmTypeKind.Collection) { // creating a new collection type here because the type in the request is just the item type, there is no user-provided collection type. var actualEntityTypeOfTheTypeSegment = actualTypeOfTheTypeSegment as IEdmEntityType; if (actualEntityTypeOfTheTypeSegment != null) { actualTypeOfTheTypeSegment = new EdmCollectionType(new EdmEntityTypeReference(actualEntityTypeOfTheTypeSegment, false)); } else { throw new ODataException(Strings.PathParser_TypeCastOnlyAllowedAfterEntityCollection(identifier)); } } var typeNameSegment = (ODataPathSegment)new TypeSegment(actualTypeOfTheTypeSegment, previous.TargetEdmNavigationSource) { Identifier = identifier, TargetKind = previous.TargetKind, SingleResult = previous.SingleResult, TargetEdmType = targetEdmType }; this.parsedSegments.Add(typeNameSegment); // Key expressions are allowed on Type segments this.TryBindKeyFromParentheses(parenthesisExpression); return true; }
private static IEdmTypeReference GetEdmTypeReference(Dictionary<Type, IEdmType> availableTypes, IEdmTypeConfiguration configuration, bool nullable) { Contract.Assert(availableTypes != null); if (configuration == null) { return null; } EdmTypeKind kind = configuration.Kind; if (kind == EdmTypeKind.Collection) { CollectionTypeConfiguration collectionType = (CollectionTypeConfiguration)configuration; EdmCollectionType edmCollectionType = new EdmCollectionType(GetEdmTypeReference(availableTypes, collectionType.ElementType, nullable)); return new EdmCollectionTypeReference(edmCollectionType); } else { Type configurationClrType = TypeHelper.GetUnderlyingTypeOrSelf(configuration.ClrType); if (!configurationClrType.GetTypeInfo().IsEnum) { configurationClrType = configuration.ClrType; } IEdmType type; if (availableTypes.TryGetValue(configurationClrType, out type)) { if (kind == EdmTypeKind.Complex) { return new EdmComplexTypeReference((IEdmComplexType)type, nullable); } else if (kind == EdmTypeKind.Entity) { return new EdmEntityTypeReference((IEdmEntityType)type, nullable); } else if (kind == EdmTypeKind.Enum) { return new EdmEnumTypeReference((IEdmEnumType)type, nullable); } else { throw Error.InvalidOperation(SRResources.UnsupportedEdmTypeKind, kind.ToString()); } } else if (configuration.Kind == EdmTypeKind.Primitive) { PrimitiveTypeConfiguration primitiveTypeConfiguration = configuration as PrimitiveTypeConfiguration; return new EdmPrimitiveTypeReference(primitiveTypeConfiguration.EdmPrimitiveType, nullable); } else { throw Error.InvalidOperation(SRResources.NoMatchingIEdmTypeFound, configuration.FullName); } } }
public void GetClrTypeNameShouldReturnICollectionStructureTemplateForCollectionOfEntityType() { EdmEntityType entityType = new EdmEntityType("Namespace", "elementName"); IEdmTypeReference elementTypeReference = new EdmTypeReferenceForTest(entityType, false); IEdmCollectionType collectionType = new EdmCollectionType(elementTypeReference); IEdmTypeReference collectionTypeReference = new EdmTypeReferenceForTest(collectionType, false); ODataT4CodeGenerator.Utils.GetClrTypeName(collectionTypeReference, false, template, context, true, true, true) .Should().Be("global::System.Collections.Generic.ICollection<global::NamespacePrefix.elementName>"); }
public void GetClrTypeNameShouldReturnICollectionStructureTemplateForCollectionOfEnumType() { EdmEnumType gender = new EdmEnumType("Namespace", "Gender", EdmPrimitiveTypeKind.Byte, true); gender.AddMember("Male", new EdmIntegerConstant(1)); gender.AddMember("Female", new EdmIntegerConstant(2)); IEdmTypeReference elementTypeReference = new EdmTypeReferenceForTest(gender, false); IEdmCollectionType collectionType = new EdmCollectionType(elementTypeReference); IEdmTypeReference collectionTypeReference = new EdmTypeReferenceForTest(collectionType, false); ODataT4CodeGenerator.Utils.GetClrTypeName(collectionTypeReference, false, template, context, true, true, true) .Should().Be("global::System.Collections.Generic.ICollection<global::NamespacePrefix.Gender>"); }
public void GetClrTypeNameShouldReturnICollectionStructureTemplateForCollectionOfPrimitiveType() { EdmPrimitiveType primitiveType = new EdmPrimitiveType(EdmPrimitiveTypeKind.String); IEdmTypeReference elementTypeReference = new EdmTypeReferenceForTest(primitiveType, false); IEdmCollectionType collectionType = new EdmCollectionType(elementTypeReference); IEdmTypeReference collectionTypeReference = new EdmTypeReferenceForTest(collectionType, false); ODataT4CodeGenerator.Utils.GetClrTypeName(collectionTypeReference, false, template, context, true, true, true) .Should().Be("global::System.Collections.Generic.ICollection<string>"); }
public void GetClrTypeNameShouldReturnDataServiceCollectionStructureTemplate() { EdmEntityType entityType = new EdmEntityType("Namespace", "elementName"); IEdmTypeReference elementTypeReference = new EdmTypeReferenceForTest(entityType, false); IEdmCollectionType collectionType = new EdmCollectionType(elementTypeReference); IEdmTypeReference collectionTypeReference = new EdmTypeReferenceForTest(collectionType, false); ODataT4CodeGenerator.Utils.GetClrTypeName(collectionTypeReference, true, template, context).Should().Be("global::Microsoft.OData.Client.DataServiceCollection<global::NamespacePrefix.elementName>"); }
public void GetClrTypeNameShouldReturnObservableCollectionStructureTemplate() { EdmComplexType complexType = new EdmComplexType("Namespace", "elementName"); IEdmTypeReference elementTypeReference = new EdmTypeReferenceForTest(complexType, false); IEdmCollectionType collectionType = new EdmCollectionType(elementTypeReference); IEdmTypeReference collectionTypeReference = new EdmTypeReferenceForTest(collectionType, false); ODataT4CodeGenerator.Utils.GetClrTypeName(collectionTypeReference, true, template, context).Should().Be("global::System.Collections.ObjectModel.ObservableCollection<global::NamespacePrefix.elementName>"); }
public void GetPropertyInitializationValueShouldReturnConstructorWithNoParametersForElementsInEntityTypeButNotUseDataServiceCollection() { EdmEntityType entityType = new EdmEntityType("Namespace", "elementName"); IEdmTypeReference elementTypeReference = new EdmTypeReferenceForTest(entityType, false); IEdmCollectionType collectionType = new EdmCollectionType(elementTypeReference); IEdmCollectionTypeReference collectionTypeReference = new EdmCollectionTypeReference(collectionType); EdmPropertyForTest property = new EdmPropertyForTest(new EdmStructruedTypeForTest(), "propertyName", collectionTypeReference); ODataT4CodeGenerator.Utils.GetPropertyInitializationValue(property, false, template, context).Should().Be("new global::System.Collections.ObjectModel.Collection<global::NamespacePrefix.elementName>()"); }
public void GetPropertyInitializationValueShouldReturnConstructorWithDataServiceCollectionConstructorParameters() { EdmEntityType entityType = new EdmEntityType("Namespace", "elementName"); IEdmTypeReference elementTypeReference = new EdmTypeReferenceForTest(entityType, false); IEdmCollectionType collectionType = new EdmCollectionType(elementTypeReference); IEdmCollectionTypeReference collectionTypeReference = new EdmCollectionTypeReference(collectionType); EdmPropertyForTest property = new EdmPropertyForTest(new EdmStructruedTypeForTest(), "propertyName", collectionTypeReference); ODataT4CodeGenerator.Utils.GetPropertyInitializationValue(property, true, template, context).Should().Be("new global::Microsoft.OData.Client.DataServiceCollection<global::NamespacePrefix.elementName>(null, global::Microsoft.OData.Client.TrackingMode.None)"); }
public void GetPropertyInitializationValueShouldReturnConstructorWithNoParametersForElementsInPrimitiveType() { EdmPrimitiveType primitiveType = new EdmPrimitiveType(EdmPrimitiveTypeKind.String); IEdmTypeReference elementTypeReference = new EdmTypeReferenceForTest(primitiveType, false); IEdmCollectionType collectionType = new EdmCollectionType(elementTypeReference); IEdmCollectionTypeReference collectionTypeReference = new EdmCollectionTypeReference(collectionType); EdmPropertyForTest property = new EdmPropertyForTest(new EdmStructruedTypeForTest(), "propertyName", collectionTypeReference); ODataT4CodeGenerator.Utils.GetPropertyInitializationValue(property, false, template, context).Should().Be("new global::System.Collections.ObjectModel.Collection<string>()"); }
public void FindMatchedOpeartions_CanFind_BindableFunctions_EntityCollection(string segment, bool isDerivedType) { // Arrange IEdmTypeReference entityType = isDerivedType ? _derivedEntityType : _entityType; var entityCollection = new EdmCollectionType(entityType); // Act var results = _model.FindMatchedOperations(segment, entityCollection); // Assert Assert.Equal(new[] { "NS.FunctionBoundToEntityCollection" }, results.Select(f => f.FullName())); }