public void ConstructableTypeReferenceToStringTest() { IEdmEntityType astonishing = new EdmEntityType("AwesomeNamespace", "AstonishingEntity", null, false, false); IEdmComplexType breathTaking = new EdmComplexType("AwesomeNamespace", "BreathtakingComplex", null, false); IEdmEntityTypeReference entity = new EdmEntityTypeReference(astonishing, true); IEdmComplexTypeReference complex = new EdmComplexTypeReference(breathTaking, true); IEdmPrimitiveTypeReference primitive = EdmCoreModel.Instance.GetInt32(true); IEdmStringTypeReference stringType = EdmCoreModel.Instance.GetString(false, 128, false, true); IEdmBinaryTypeReference binary = EdmCoreModel.Instance.GetBinary(true, null, true); IEdmTemporalTypeReference temporal = EdmCoreModel.Instance.GetTemporal(EdmPrimitiveTypeKind.DateTimeOffset, 1, true); IEdmDecimalTypeReference decimalType = EdmCoreModel.Instance.GetDecimal(3, 2, true); IEdmSpatialTypeReference spatial = EdmCoreModel.Instance.GetSpatial(EdmPrimitiveTypeKind.Geography, 1, true); IEdmEntityReferenceTypeReference entityRef = new EdmEntityReferenceTypeReference(new EdmEntityReferenceType(astonishing), true); IEdmCollectionTypeReference collection = EdmCoreModel.GetCollection(EdmCoreModel.Instance.GetInt32(true)); IEdmTypeReference type = new EdmEntityTypeReference(astonishing, true); Assert.AreEqual("[AwesomeNamespace.AstonishingEntity Nullable=True]", entity.ToString(), "To string correct"); Assert.AreEqual("[AwesomeNamespace.BreathtakingComplex Nullable=True]", complex.ToString(), "To string correct"); Assert.AreEqual("[Edm.Int32 Nullable=True]", primitive.ToString(), "To string correct"); Assert.AreEqual("[Edm.String Nullable=True MaxLength=128 Unicode=False]", stringType.ToString(), "To string correct"); Assert.AreEqual("[Edm.Binary Nullable=True MaxLength=max]", binary.ToString(), "To string correct"); Assert.AreEqual("[Edm.DateTimeOffset Nullable=True Precision=1]", temporal.ToString(), "To string correct"); Assert.AreEqual("[Edm.Decimal Nullable=True Precision=3 Scale=2]", decimalType.ToString(), "To string correct"); Assert.AreEqual("[Edm.Geography Nullable=True SRID=1]", spatial.ToString(), "To string correct"); Assert.AreEqual("[Collection([Edm.Int32 Nullable=True]) Nullable=True]", collection.ToString(), "To string correct"); Assert.AreEqual("[EntityReference(AwesomeNamespace.AstonishingEntity) Nullable=True]", entityRef.ToString(), "To string correct"); Assert.AreEqual("[AwesomeNamespace.AstonishingEntity Nullable=True]", type.ToString(), "To string correct"); }
public void CreateEdmTypeSchemaReturnSchemaForComplexType(bool isNullable) { // Arrange IEdmModel model = EdmModelHelper.TripServiceModel; IEdmComplexType complex = model.SchemaElements.OfType <IEdmComplexType>().First(c => c.Name == "AirportLocation"); Assert.NotNull(complex); // guard IEdmComplexTypeReference complexTypeReference = new EdmComplexTypeReference(complex, isNullable); ODataContext context = new ODataContext(model); // Act var schema = context.CreateEdmTypeSchema(complexTypeReference); // & Assert Assert.NotNull(schema); if (isNullable) { Assert.Null(schema.Reference); Assert.NotNull(schema.AnyOf); Assert.NotEmpty(schema.AnyOf); var anyOf = Assert.Single(schema.AnyOf); Assert.NotNull(anyOf.Reference); Assert.Equal(ReferenceType.Schema, anyOf.Reference.Type); Assert.Equal(complex.FullTypeName(), anyOf.Reference.Id); } else { Assert.Null(schema.AnyOf); Assert.NotNull(schema.Reference); Assert.Equal(ReferenceType.Schema, schema.Reference.Type); Assert.Equal(complex.FullTypeName(), schema.Reference.Id); } }
public void SerializeTopLevelPropertyOfComplexTypeShouldWork() { EdmModel model = new EdmModel(); EdmComplexType complexType = new EdmComplexType("ns", "complex"); complexType.AddProperty(new EdmStructuralProperty(complexType, "propertyName1", EdmCoreModel.Instance.GetInt32(isNullable: false))); complexType.AddProperty(new EdmStructuralProperty(complexType, "propertyName2", EdmCoreModel.Instance.GetString(isNullable: false))); model.AddElement(complexType); EdmComplexTypeReference complexReference = new EdmComplexTypeReference(complexType, isNullable: false); EdmEntityType entityType = new EdmEntityType("ns", "entityType", baseType: null, isAbstract: false, isOpen: false); entityType.AddStructuralProperty("complexPropertyName", complexReference); model.AddElement(entityType); ODataComplexValue complexValue = new ODataComplexValue { Properties = new[] { new ODataProperty { Name = "propertyName1", Value = 1 }, new ODataProperty { Name = "propertyName2", Value = "stringValue" } }, TypeName = "ns.complex" }; ODataProperty complexProperty = new ODataProperty { Name = "complexPropertyName", Value = complexValue }; string val = SerializeProperty(model, complexProperty); val.Should().Be("<?xml version=\"1.0\" encoding=\"utf-8\"?><m:value xmlns:d=\"http://docs.oasis-open.org/odata/ns/data\" xmlns:georss=\"http://www.georss.org/georss\" xmlns:gml=\"http://www.opengis.net/gml\" m:context=\"http://odata.org/$metadata#ns.complex\" m:type=\"#ns.complex\" xmlns:m=\"http://docs.oasis-open.org/odata/ns/metadata\"><d:propertyName1 m:type=\"Int32\">1</d:propertyName1><d:propertyName2>stringValue</d:propertyName2></m:value>"); }
public void CreateODataCollectionValue_CanSerialize_IEdmObjects() { // Arrange Mock <IEdmComplexObject> edmComplexObject = new Mock <IEdmComplexObject>(); IEdmComplexObject[] collection = new IEdmComplexObject[] { edmComplexObject.Object }; ODataSerializerContext serializerContext = new ODataSerializerContext(); IEdmComplexTypeReference elementType = new EdmComplexTypeReference(new EdmComplexType("NS", "ComplexType"), isNullable: true); edmComplexObject.Setup(s => s.GetEdmType()).Returns(elementType); IEdmCollectionTypeReference collectionType = new EdmCollectionTypeReference(new EdmCollectionType(elementType)); Mock <ODataSerializerProvider> serializerProvider = new Mock <ODataSerializerProvider>(); Mock <ODataComplexTypeSerializer> elementSerializer = new Mock <ODataComplexTypeSerializer>(MockBehavior.Strict, serializerProvider.Object); serializerProvider.Setup(s => s.GetEdmTypeSerializer(elementType)).Returns(elementSerializer.Object); elementSerializer.Setup(s => s.CreateODataComplexValue(collection[0], elementType, serializerContext)).Returns(new ODataComplexValue()).Verifiable(); ODataCollectionSerializer serializer = new ODataCollectionSerializer(serializerProvider.Object); // Act var result = serializer.CreateODataCollectionValue(collection, elementType, serializerContext); // Assert elementSerializer.Verify(); }
public async Task WriteResourceValueAsync_WritesExpectedValueForOpenProperty() { var resourceValue = new ODataResourceValue { Properties = new List <ODataProperty> { new ODataProperty { Name = "LuckyNumber", Value = new ODataPrimitiveValue(13) }, new ODataProperty { Name = "FavoriteColor", Value = new ODataEnumValue("Black") } }, TypeName = "NS.Attributes" }; var metadataTypeReference = new EdmComplexTypeReference(this.attributesComplexType, false); var result = await SetupJsonLightValueSerializerAndRunTestAsync( (jsonLightValueSerializer) => { return(jsonLightValueSerializer.WriteResourceValueAsync( resourceValue, metadataTypeReference, /* isOpenProperty */ true, new NullDuplicatePropertyNameChecker())); }); Assert.Equal("{\"@odata.type\":\"#NS.Attributes\",\"LuckyNumber\":13,\"FavoriteColor\":\"Black\"}", result); }
public void GetClrType_Cached_OnlyOneInstance() { // Arrange ClrTypeCache cache = new ClrTypeCache(); Type clrType = typeof(CacheAddress); IEdmComplexType address = _model.SchemaElements.OfType <IEdmComplexType>().FirstOrDefault(c => c.Name == "Address"); Action cacheCallAndVerify = () => { IEdmComplexTypeReference addressTypeTrue = new EdmComplexTypeReference(address, true); Type actual = cache.GetClrType(addressTypeTrue, _model); Assert.Same(clrType, actual); IEdmComplexTypeReference addressTypeFalse = new EdmComplexTypeReference(address, false); actual = cache.GetClrType(addressTypeFalse, _model); Assert.Same(clrType, actual); Assert.Equal(2, cache.EdmToClrTypeCache.Count); }; // Act & Assert cacheCallAndVerify(); // 5 is a magic number, it doesn't matter, just want to call it mulitple times. for (int i = 0; i < 5; i++) { cacheCallAndVerify(); } cacheCallAndVerify(); }
public void ReadingTypeDefinitionPayloadWithEdmTypeAnnotationJsonLight() { EdmModel model = new EdmModel(); EdmEntityType entityType = new EdmEntityType("NS", "Person"); entityType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32); EdmTypeDefinition weightType = new EdmTypeDefinition("NS", "Weight", EdmPrimitiveTypeKind.Double); EdmTypeDefinitionReference weightTypeRef = new EdmTypeDefinitionReference(weightType, false); entityType.AddStructuralProperty("Weight", weightTypeRef); EdmTypeDefinition heightType = new EdmTypeDefinition("NS", "Height", EdmPrimitiveTypeKind.Double); EdmComplexType complexType = new EdmComplexType("NS", "OpenAddress"); EdmComplexTypeReference complexTypeRef = new EdmComplexTypeReference(complexType, true); EdmTypeDefinition addressType = new EdmTypeDefinition("NS", "Address", EdmPrimitiveTypeKind.String); EdmTypeDefinitionReference addressTypeRef = new EdmTypeDefinitionReference(addressType, false); complexType.AddStructuralProperty("CountryRegion", addressTypeRef); entityType.AddStructuralProperty("Address", complexTypeRef); model.AddElement(weightType); model.AddElement(heightType); model.AddElement(addressType); model.AddElement(complexType); model.AddElement(entityType); EdmEntityContainer container = new EdmEntityContainer("EntityNs", "MyContainer"); EdmEntitySet entitySet = container.AddEntitySet("People", entityType); model.AddElement(container); const string payload = "{" + "\"@odata.context\":\"http://www.example.com/$metadata#EntityNs.MyContainer.People/$entity\"," + "\"@odata.id\":\"http://mytest\"," + "\"Id\":0," + "\"[email protected]\":\"#Edm.Double\"," + "\"Weight\":60.5," + "\"Address\":{\"[email protected]\":\"#Edm.String\",\"CountryRegion\":\"China\"}" + "}"; ODataEntry entry = null; this.ReadEntryPayload(model, payload, entitySet, entityType, reader => { entry = entry ?? reader.Item as ODataEntry; }); Assert.IsNotNull(entry, "entry shouldn't be null"); IList <ODataProperty> propertyList = entry.Properties.ToList(); propertyList[1].Name.Should().Be("Weight"); propertyList[1].Value.Should().Be(60.5); var address = propertyList[2].Value as ODataComplexValue; address.Properties.FirstOrDefault(s => string.Equals(s.Name, "CountryRegion", StringComparison.OrdinalIgnoreCase)).Value.Should().Be("China"); }
private IEdmTypeReference BuildTypeReference(EntityRelationElement relationElement) { var complexType = (IEdmComplexType)BuildSchemaType(relationElement.Target); IEdmTypeReference typeReference; switch (relationElement.Cardinality) { case EntityRelationCardinality.One: typeReference = new EdmComplexTypeReference(complexType, false); break; case EntityRelationCardinality.OptionalOne: typeReference = new EdmComplexTypeReference(complexType, true); break; case EntityRelationCardinality.Many: typeReference = EdmCoreModel.GetCollection(new EdmComplexTypeReference(complexType, true)); break; default: throw new ArgumentOutOfRangeException(); } return(typeReference); }
public void WritingMultipleInstanceAnnotationInResourceValueShouldWrite(string filter, string expect) { var complexType = new EdmComplexType("NS", "Address"); model.AddElement(complexType); settings.ShouldIncludeAnnotation = ODataUtils.CreateAnnotationFilter(filter); var result = this.SetupSerializerAndRunTest(serializer => { var resourceValue = new ODataResourceValue { TypeName = "NS.Address", InstanceAnnotations = new Collection <ODataInstanceAnnotation> { new ODataInstanceAnnotation("Custom.Bool", new ODataPrimitiveValue(true)), new ODataInstanceAnnotation("Custom.Int", new ODataPrimitiveValue(123)), new ODataInstanceAnnotation("My.String", new ODataPrimitiveValue("annotation")), new ODataInstanceAnnotation("My.Bool", new ODataPrimitiveValue(false)) } }; var complexTypeRef = new EdmComplexTypeReference(complexType, false); serializer.WriteResourceValue(resourceValue, complexTypeRef, false, serializer.CreateDuplicatePropertyNameChecker()); }); Assert.Equal(expect, result); }
public static IEdmModel Build() { var addressType = new EdmComplexType(Namespace, "address"); addressType.AddStructuralProperty("street", EdmPrimitiveTypeKind.String); addressType.AddStructuralProperty("city", EdmPrimitiveTypeKind.String); var addressTypeRef = new EdmComplexTypeReference(addressType, isNullable: false); var addressesTypeRef = EdmCoreModel.GetCollection(addressTypeRef); var nonNullableStringTypeRef = EdmCoreModel.Instance.GetString(isNullable: false); var tagsTypeRef = EdmCoreModel.GetCollection(nonNullableStringTypeRef); var docEntityType = new EdmEntityType(Namespace, DocEntityTypeName); EdmStructuralProperty key = docEntityType.AddStructuralProperty("id", EdmPrimitiveTypeKind.String); docEntityType.AddKeys(key); docEntityType.AddStructuralProperty("addresses", addressesTypeRef); docEntityType.AddStructuralProperty("tags", tagsTypeRef); var docEntitySetType = EdmCoreModel.GetCollection(new EdmEntityTypeReference(docEntityType, isNullable: true)); var container = new EdmEntityContainer("Default", "Container"); container.AddEntitySet("Docs", docEntityType); var model = new EdmModel(); model.AddElements(new IEdmSchemaElement[] { container, addressType, docEntityType }); return(model); }
public ODataJsonLightCollectionWriterTests() { collectionStartWithoutSerializationInfo = new ODataCollectionStart(); collectionStartWithSerializationInfo = new ODataCollectionStart(); collectionStartWithSerializationInfo.SetSerializationInfo(new ODataCollectionStartSerializationInfo { CollectionTypeName = "Collection(ns.Address)" }); address = new ODataComplexValue { Properties = new[] { new ODataProperty { Name = "Street", Value = "1 Microsoft Way" }, new ODataProperty { Name = "Zipcode", Value = 98052 }, new ODataProperty { Name = "State", Value = new ODataEnumValue("WA", "ns.StateEnum") } } }; items = new[] { address }; EdmComplexType addressType = new EdmComplexType("ns", "Address"); addressType.AddProperty(new EdmStructuralProperty(addressType, "Street", EdmCoreModel.Instance.GetString(isNullable: true))); addressType.AddProperty(new EdmStructuralProperty(addressType, "Zipcode", EdmCoreModel.Instance.GetInt32(isNullable: true))); var stateEnumType = new EdmEnumType("ns", "StateEnum", isFlags: true); stateEnumType.AddMember("IL", new EdmIntegerConstant(1)); stateEnumType.AddMember("WA", new EdmIntegerConstant(2)); addressType.AddProperty(new EdmStructuralProperty(addressType, "State", new EdmEnumTypeReference(stateEnumType, true))); addressTypeReference = new EdmComplexTypeReference(addressType, isNullable: false); }
public ODataJsonLightValueSerializerAsyncTests() { this.model = new EdmModel(); this.colorEnumType = new EdmEnumType("NS", "Color"); colorEnumType.AddMember(new EdmEnumMember(colorEnumType, "Black", new EdmEnumMemberValue(0))); colorEnumType.AddMember(new EdmEnumMember(colorEnumType, "White", new EdmEnumMemberValue(1))); this.model.AddElement(this.colorEnumType); attributesComplexType = new EdmComplexType("NS", "Attributes"); attributesComplexType.AddStructuralProperty("LuckyNumber", EdmPrimitiveTypeKind.Int32); attributesComplexType.AddStructuralProperty("FavoriteColor", new EdmEnumTypeReference(colorEnumType, false)); this.model.AddElement(this.attributesComplexType); EdmComplexTypeReference attributesComplexTypeRef = new EdmComplexTypeReference(attributesComplexType, true); this.entityType = new EdmEntityType("NS", "EntityType"); entityType.AddKeys(entityType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32)); entityType.AddStructuralProperty("Attributes", new EdmCollectionTypeReference(new EdmCollectionType(attributesComplexTypeRef))); this.model.AddElement(this.entityType); this.stream = new MemoryStream(); this.settings = new ODataMessageWriterSettings { EnableMessageStreamDisposal = false, Version = ODataVersion.V4 }; this.settings.SetServiceDocumentUri(new Uri("http://tempuri.org")); }
public void ApplyAnnotations_FailsWithUsefulErrorMessageOnUnknownProperty() { // Arrange const string HelpfulErrorMessage = "The property 'Unknown' does not exist on type 'namespace.name'. Make sure to only use property names " + "that are defined by the type."; var property = new ODataProperty { Name = "Unknown", Value = "Value" }; var entityType = new EdmComplexType("namespace", "name"); entityType.AddStructuralProperty("Known", EdmLibHelpers.GetEdmPrimitiveTypeReferenceOrNull(typeof(string))); var entityTypeReference = new EdmComplexTypeReference(entityType, isNullable: false); // Act var exception = Assert.Throws <ODataException>(() => DeserializationHelpers.ApplyProperty( property, entityTypeReference, resource: null, deserializerProvider: null, readContext: null)); // Assert Assert.Equal(HelpfulErrorMessage, exception.Message); }
public void WritingMultipleInstanceAnnotationInComplexValueShouldWrite() { var complexType = new EdmComplexType("TestNamespace", "Address"); model.AddElement(complexType); settings.ShouldIncludeAnnotation = ODataUtils.CreateAnnotationFilter("*"); var result = this.SetupSerializerAndRunTest(serializer => { var complexValue = new ODataComplexValue { TypeName = "TestNamespace.Address", InstanceAnnotations = new Collection <ODataInstanceAnnotation> { new ODataInstanceAnnotation("Annotation.1", new ODataPrimitiveValue(true)), new ODataInstanceAnnotation("Annotation.2", new ODataPrimitiveValue(123)), new ODataInstanceAnnotation("Annotation.3", new ODataPrimitiveValue("annotation")) } }; var complexTypeRef = new EdmComplexTypeReference(complexType, false); serializer.WriteComplexValue(complexValue, complexTypeRef, false, false, new DuplicatePropertyNamesChecker(false, true)); }); result.Should().Contain("\"@Annotation.1\":true,\"@Annotation.2\":123,\"@Annotation.3\":\"annotation\""); }
public void EqualsOnComplexTypesWithDifferentNullabilityIsSupported() { var notNullableType = new EdmComplexTypeReference(HardCodedTestModel.GetAddressType(), false); var nullableType = new EdmComplexTypeReference(HardCodedTestModel.GetAddressType(), true); IEdmTypeReference left = notNullableType; IEdmTypeReference right = nullableType; SingleValueNode leftNode = new SingleValuePropertyAccessNode(new ConstantNode(null) /*parent*/, new EdmStructuralProperty(new EdmEntityType("MyNamespace", "MyEntityType"), "myPropertyName", left)); SingleValueNode rightNode = new SingleValuePropertyAccessNode(new ConstantNode(null) /*parent*/, new EdmStructuralProperty(new EdmEntityType("MyNamespace", "MyEntityType"), "myPropertyName", right)); var result = TypePromotionUtils.PromoteOperandTypes(BinaryOperatorKind.Equal, leftNode, rightNode, out left, out right); result.Should().BeTrue(); left.ShouldBeEquivalentTo(nullableType); right.ShouldBeEquivalentTo(nullableType); // Reverse order left = nullableType; right = notNullableType; leftNode = new SingleValuePropertyAccessNode(new ConstantNode(null) /*parent*/, new EdmStructuralProperty(new EdmEntityType("MyNamespace", "MyEntityType"), "myPropertyName", left)); rightNode = new SingleValuePropertyAccessNode(new ConstantNode(null) /*parent*/, new EdmStructuralProperty(new EdmEntityType("MyNamespace", "MyEntityType"), "myPropertyName", right)); result = TypePromotionUtils.PromoteOperandTypes(BinaryOperatorKind.Equal, leftNode, rightNode, out left, out right); result.Should().BeTrue(); left.ShouldBeEquivalentTo(nullableType); right.ShouldBeEquivalentTo(nullableType); }
private static object ConvertComplexValue(ODataComplexValue complexValue, ref IEdmTypeReference propertyType, ODataDeserializerProvider deserializerProvider, ODataDeserializerContext readContext) { IEdmComplexTypeReference edmComplexType; if (propertyType == null) { // open complex property Contract.Assert(!String.IsNullOrEmpty(complexValue.TypeName), "ODataLib should have verified that open complex value has a type name since we provided metadata."); IEdmModel model = readContext.Model; IEdmType edmType = model.FindType(complexValue.TypeName); Contract.Assert(edmType.TypeKind == EdmTypeKind.Complex, "ODataLib should have verified that complex value has a complex resource type."); edmComplexType = new EdmComplexTypeReference(edmType as IEdmComplexType, isNullable: true); propertyType = edmComplexType; } else { edmComplexType = propertyType.AsComplex(); } ODataEdmTypeDeserializer deserializer = deserializerProvider.GetEdmTypeDeserializer(edmComplexType); return(deserializer.ReadInline(complexValue, propertyType, readContext)); }
private static ODataValue GetComplexValue(InstanceAnnotation entryAnnotation, object annotation, IEdmModel model, ODataComplexTypeSerializer complexSerializer, ODataSerializerContext serializerContext) { Contract.Requires(entryAnnotation != null); Contract.Requires(annotation != null); Contract.Requires(model != null); Contract.Requires(complexSerializer != null); Contract.Requires(serializerContext != null); var complexType = (IEdmComplexType)model.FindDeclaredType(entryAnnotation.AnnotationTypeName); if (complexType == null) { return(null); } var typeRef = new EdmComplexTypeReference(complexType, entryAnnotation.IsNullable); if (!entryAnnotation.IsCollection) { return(complexSerializer.CreateODataComplexValue(annotation, typeRef, serializerContext)); } var typeName = Invariant($"Collection({typeRef.FullName()})"); var items = GetComplexValues(annotation, complexSerializer, typeRef, serializerContext); return(new ODataCollectionValue() { Items = items, TypeName = typeName }); }
public LocalizedTextDataType(IODataObjectFactory oDataObjectFactory) { this.oDataObjectFactory = oDataObjectFactory; this.cultureValueTypeReference = CreateCultureValueTypeReference(); this.cultureValuesCollectionTypeReference = CreateCultureValuesCollectionTypeReference(this.cultureValueTypeReference); this.edmComplexType = CreateComplexType(this.cultureValuesCollectionTypeReference); }
public void Initialize() { var addressEdmType = new EdmComplexType("Default", "Address"); addressEdmType.AddStructuralProperty("ZipCode", EdmPrimitiveTypeKind.String); this.edmAddressComplexTypeRef = new EdmComplexTypeReference(addressEdmType, true); }
private EdmStructuralProperty?BuildStructuralProperty(Dictionary <Type, EntityTypeInfo> entityTypes, Dictionary <Type, EdmEnumType> enumTypes, Dictionary <Type, EdmComplexType> complexTypes, PropertyInfo clrProperty) { bool isNullable = !_metadataProvider.IsRequired(clrProperty); IEdmTypeReference?typeRef = PrimitiveTypeHelper.GetPrimitiveTypeRef(clrProperty, isNullable); if (typeRef == null) { Type?underlyingType = null; if (clrProperty.PropertyType.IsEnum || (underlyingType = Nullable.GetUnderlyingType(clrProperty.PropertyType)) != null && underlyingType.IsEnum) { Type clrPropertyType = underlyingType ?? clrProperty.PropertyType; if (!enumTypes.TryGetValue(clrPropertyType, out EdmEnumType? edmEnumType)) { edmEnumType = OeEdmModelBuilder.CreateEdmEnumType(clrPropertyType); enumTypes.Add(clrPropertyType, edmEnumType); } typeRef = new EdmEnumTypeReference(edmEnumType, underlyingType != null); } else { if (complexTypes.TryGetValue(clrProperty.PropertyType, out EdmComplexType? edmComplexType)) { typeRef = new EdmComplexTypeReference(edmComplexType, clrProperty.PropertyType.IsClass); } else { FKeyInfo?fkeyInfo = FKeyInfo.Create(_metadataProvider, entityTypes, this, clrProperty); if (fkeyInfo != null) { _navigationClrProperties.Add(fkeyInfo); } return(null); } } } else { if (clrProperty.PropertyType == typeof(DateTime?) && enumTypes.ContainsKey(typeof(DateTime?))) { var edmType = enumTypes[typeof(DateTime?)]; typeRef = new EdmEnumTypeReference(edmType, true); } } EdmStructuralProperty edmProperty = clrProperty is Infrastructure.OeShadowPropertyInfo ? new OeEdmStructuralShadowProperty(EdmType, clrProperty.Name, typeRef, clrProperty) : new EdmStructuralProperty(EdmType, clrProperty.Name, typeRef); EdmType.AddProperty(edmProperty); if (_metadataProvider.IsKey(clrProperty)) { _keyProperties.Add(new KeyValuePair <PropertyInfo, EdmStructuralProperty>(clrProperty, edmProperty)); } return(edmProperty); }
public void GetEdmType_Returns_EdmTypeInitializedByCtor() { IEdmTypeReference elementType = new EdmComplexTypeReference(new EdmComplexType("NS", "Complex"), isNullable: false); IEdmCollectionTypeReference collectionType = new EdmCollectionTypeReference(new EdmCollectionType(elementType)); var edmObject = new EdmComplexObjectCollection(collectionType); Assert.Same(collectionType, edmObject.GetEdmType()); }
private void VerifyComplexTypeRoundtrip(ODataComplexValue value, string typeName) { var typeReference = new EdmComplexTypeReference((IEdmComplexType)model.FindType(typeName), true); MemoryStream stream = new MemoryStream(); using (ODataAtomOutputContext outputContext = new ODataAtomOutputContext( ODataFormat.Atom, new NonDisposingStream(stream), Encoding.UTF8, new ODataMessageWriterSettings() { Version = ODataVersion.V4 }, /*writingResponse*/ true, /*synchronous*/ true, model, /*urlResolver*/ null)) { ODataAtomPropertyAndValueSerializer serializer = new ODataAtomPropertyAndValueSerializer(outputContext); serializer.XmlWriter.WriteStartElement("ValueElement"); serializer.WriteComplexValue( value, typeReference, /*isOpenPropertyType*/ false, /*isWritingCollection*/ false, /*beforeValueAction*/ null, /*afterValueAction*/ null, new DuplicatePropertyNamesChecker(false, false), /*collectionValidator*/ null, /*projectedProperties*/ null); serializer.XmlWriter.WriteEndElement(); } stream.Position = 0; object actualValue; using (ODataAtomInputContext inputContext = new ODataAtomInputContext( ODataFormat.Atom, stream, Encoding.UTF8, new ODataMessageReaderSettings(), /*readingResponse*/ true, /*synchronous*/ true, model, /*urlResolver*/ null)) { ODataAtomPropertyAndValueDeserializer deserializer = new ODataAtomPropertyAndValueDeserializer(inputContext); deserializer.XmlReader.MoveToContent(); actualValue = deserializer.ReadNonEntityValue( typeReference, /*duplicatePropertyNamesChecker*/ null, /*collectionValidator*/ null, /*validateNullValue*/ true); } TestUtils.AssertODataValueAreEqual(actualValue as ODataValue, value); }
public void CreateODataComplexValue_ReturnsNull_ForNullEdmComplexObject() { IEdmComplexTypeReference edmType = new EdmComplexTypeReference(_addressType, isNullable: true); ODataComplexTypeSerializer serializer = new ODataComplexTypeSerializer(new DefaultODataSerializerProvider()); var result = serializer.CreateODataComplexValue(new NullEdmComplexObject(edmType), edmType, new ODataSerializerContext()); Assert.Null(result); }
public void TryGetValue_ThrowsInvalidOperation_EdmComplexObjectNullRef() { IEdmComplexTypeReference edmType = new EdmComplexTypeReference(new EdmComplexType("NS", "ComplexType"), isNullable: true); NullEdmComplexObject nullComplexObject = new NullEdmComplexObject(edmType); object propertyValue; ExceptionAssert.Throws <InvalidOperationException>(() => nullComplexObject.TryGetPropertyValue("property", out propertyValue), "Cannot get property 'property' of a null EDM object of type '[NS.ComplexType Nullable=True]'."); }
public void GetEdmType_Returns_CtorInitializedValue() { IEdmComplexTypeReference edmType = new EdmComplexTypeReference(new EdmComplexType("NS", "ComplexType"), isNullable: true); NullEdmComplexObject nullComplexObject = new NullEdmComplexObject(edmType); IEdmTypeReference result = nullComplexObject.GetEdmType(); Assert.Same(edmType, result); }
public void TryGetPropertyValue_ThrowsInvalidOperation() { // Arrange & Act & Assert EdmComplexType complex = new EdmComplexType("NS", "Complex"); IEdmComplexTypeReference typeRef = new EdmComplexTypeReference(complex, false); NullEdmComplexObject obj = new NullEdmComplexObject(typeRef); ExceptionAssert.Throws <InvalidOperationException>(() => obj.TryGetPropertyValue("name", out object value), "Cannot get property 'name' of a null EDM object of type '[NS.Complex Nullable=False]'."); }
public void TypeNameShouldBeWrittenForUndeclaredComplexProperty() { var typeFromValue = new EdmComplexTypeReference(new EdmComplexType("Test", "ComplexType"), false); this.typeNameOracle.GetResourceTypeNameForWriting(null, new ODataResource { TypeName = "Test.ComplexType" }, /* isUndeclared*/ true).Should().Be("Test.ComplexType"); }
public void GetDefaultValue_NonNullableComplex() { IEdmTypeReference nonNullableComplexType = new EdmComplexTypeReference(new EdmComplexType("NS", "Complex"), isNullable: false); var result = EdmStructuredObject.GetDefaultValue(nonNullableComplexType); var complexObject = Assert.IsType <EdmComplexObject>(result); Assert.Equal(nonNullableComplexType, complexObject.GetEdmType(), new EdmTypeReferenceEqualityComparer()); }
private void BuildProperty(Dictionary <Type, EntityTypeInfo> entityTypes, Dictionary <Type, EdmEnumType> enumTypes, Dictionary <Type, EdmComplexType> complexTypes, PropertyDescriptor clrProperty) { IEdmTypeReference typeRef = PrimitiveTypeHelper.GetPrimitiveTypeRef(clrProperty); if (typeRef == null) { EdmEnumType edmEnumType; Type underlyingType = null; if (clrProperty.PropertyType.GetTypeInfo().IsEnum || (underlyingType = Nullable.GetUnderlyingType(clrProperty.PropertyType)) != null && underlyingType.GetTypeInfo().IsEnum) { Type clrPropertyType = underlyingType ?? clrProperty.PropertyType; if (!enumTypes.TryGetValue(clrPropertyType, out edmEnumType)) { edmEnumType = CreateEdmEnumType(clrPropertyType); enumTypes.Add(clrPropertyType, edmEnumType); } typeRef = new EdmEnumTypeReference(edmEnumType, underlyingType != null); } else { EdmComplexType edmComplexType; if (complexTypes.TryGetValue(clrProperty.PropertyType, out edmComplexType)) { typeRef = new EdmComplexTypeReference(edmComplexType, clrProperty.PropertyType.GetTypeInfo().IsClass); } else { FKeyInfo fkeyInfo = FKeyInfo.Create(_metadataProvider, entityTypes, this, clrProperty); if (fkeyInfo != null) { _navigationClrProperties.Add(fkeyInfo); } return; } } } else { if (clrProperty.PropertyType == typeof(DateTime?) && enumTypes.ContainsKey(typeof(DateTime?))) //zzz { var edmType = enumTypes[typeof(DateTime?)]; typeRef = new EdmEnumTypeReference(edmType, true); } } var edmProperty = new EdmStructuralProperty(_edmType, clrProperty.Name, typeRef); _edmType.AddProperty(edmProperty); if (_metadataProvider.IsKey(clrProperty)) { _keyProperties.Add(new KeyValuePair <PropertyDescriptor, EdmStructuralProperty>(clrProperty, edmProperty)); } }
public void GetDefaultValue_NonNullableComplexCollection() { IEdmTypeReference elementType = new EdmComplexTypeReference(new EdmComplexType("NS", "Complex"), isNullable: true); IEdmCollectionTypeReference complexCollectionType = new EdmCollectionTypeReference(new EdmCollectionType(elementType)); var result = EdmStructuredObject.GetDefaultValue(complexCollectionType); var complexCollectionObject = Assert.IsType <EdmComplexObjectCollection>(result); Assert.Equal(complexCollectionType, complexCollectionObject.GetEdmType(), new EdmTypeReferenceEqualityComparer()); }