static ODataResourceTypeContextTests()
{
Model = new EdmModel();
EntitySetElementType = new EdmEntityType("ns", "Customer");
ExpectedEntityType = new EdmEntityType("ns", "VipCustomer", EntitySetElementType);
ActualEntityType = new EdmEntityType("ns", "DerivedVipCustomer", ExpectedEntityType);
ComplexType = new EdmComplexType("ns", "Address");
EdmEntityContainer defaultContainer = new EdmEntityContainer("ns", "DefaultContainer");
Model.AddElement(defaultContainer);
EntitySet = new EdmEntitySet(defaultContainer, "Customers", EntitySetElementType);
Model.AddElement(EntitySetElementType);
Model.AddElement(ExpectedEntityType);
Model.AddElement(ActualEntityType);
defaultContainer.AddElement(EntitySet);
SerializationInfo = new ODataResourceSerializationInfo {
NavigationSourceName = "MyCustomers", NavigationSourceEntityTypeName = "ns.MyCustomer", ExpectedTypeName = "ns.MyVipCustomer"
};
SerializationInfoWithEdmUnknowEntitySet = new ODataResourceSerializationInfo()
{
NavigationSourceName = null, NavigationSourceEntityTypeName = "ns.MyCustomer", ExpectedTypeName = "ns.MyVipCustomer", NavigationSourceKind = EdmNavigationSourceKind.UnknownEntitySet
};
TypeContextWithoutModel = ODataResourceTypeContext.Create(SerializationInfo, navigationSource: null, navigationSourceEntityType: null, expectedResourceType: null, throwIfMissingTypeInfo: true);
TypeContextWithModel = ODataResourceTypeContext.Create(/*serializationInfo*/ null, EntitySet, EntitySetElementType, ExpectedEntityType, throwIfMissingTypeInfo: true);
TypeContextWithEdmUnknowEntitySet = ODataResourceTypeContext.Create(SerializationInfoWithEdmUnknowEntitySet, navigationSource: null, navigationSourceEntityType: null, expectedResourceType: null, throwIfMissingTypeInfo: true);
BaseTypeContextThatThrows = ODataResourceTypeContext.Create(serializationInfo: null, navigationSource: null, navigationSourceEntityType: null, expectedResourceType: null, throwIfMissingTypeInfo: true);
BaseTypeContextThatWillNotThrow = ODataResourceTypeContext.Create(serializationInfo: null, navigationSource: null, navigationSourceEntityType: null, expectedResourceType: null, throwIfMissingTypeInfo: false);
}
public void GetFirstNonTypeCastSegment_WorksForExpandPathWithPropertySegment()
{
// Arrange
EdmEntityType entityType = new EdmEntityType("NS", "Customer");
IEdmStructuralProperty property = entityType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.String);
var navProperty = entityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo
{
Name = "Nav",
Target = entityType,
TargetMultiplicity = EdmMultiplicity.One
});
EdmEntityContainer container = new EdmEntityContainer("NS", "Container");
EdmEntitySet set = new EdmEntitySet(container, "set", entityType);
NavigationPropertySegment navSegment = new NavigationPropertySegment(navProperty, set);
TypeSegment typeSegment = new TypeSegment(entityType, null);
ODataPathSegment propertySegment = new PropertySegment(property);
ODataExpandPath expandPath = new ODataExpandPath(typeSegment, propertySegment, navSegment);
// Act
IList<ODataPathSegment> remainingSegments;
ODataPathSegment firstNonTypeSegment = expandPath.GetFirstNonTypeCastSegment(out remainingSegments);
// Assert
Assert.NotNull(firstNonTypeSegment);
Assert.Same(propertySegment, firstNonTypeSegment);
Assert.NotNull(remainingSegments);
Assert.Same(navSegment, Assert.Single(remainingSegments));
}
private string WriterEntry(IEdmModel userModel, ODataEntry entry, EdmEntitySet entitySet, IEdmEntityType entityType, bool fullMetadata = false)
{
var message = new InMemoryMessage()
{
Stream = new MemoryStream()
};
var writerSettings = new ODataMessageWriterSettings {
DisableMessageStreamDisposal = true, AutoComputePayloadMetadataInJson = true
};
writerSettings.SetContentType(ODataFormat.Json);
writerSettings.SetServiceDocumentUri(new Uri("http://www.example.com"));
writerSettings.SetContentType(fullMetadata ?
"application/json;odata.metadata=full;odata.streaming=false" :
"application/json;odata.metadata=minimal;odata.streaming=false", "utf-8");
using (var msgReader = new ODataMessageWriter((IODataResponseMessage)message, writerSettings, userModel))
{
var writer = msgReader.CreateODataEntryWriter(entitySet, entityType);
writer.WriteStart(entry);
writer.WriteEnd();
}
message.Stream.Seek(0, SeekOrigin.Begin);
using (StreamReader reader = new StreamReader(message.Stream))
{
return(reader.ReadToEnd());
}
}
public ODataJsonLightEntryAndFeedSerializerUndeclaredTests()
{
this.serverModel = new EdmModel();
var addressType = new EdmComplexType("Server.NS", "Address");
addressType.AddStructuralProperty("Street", EdmPrimitiveTypeKind.String);
this.serverModel.AddElement(addressType);
// non-open entity type
this.serverEntityType = new EdmEntityType("Server.NS", "ServerEntityType");
this.serverModel.AddElement(this.serverEntityType);
this.serverEntityType.AddKeys(this.serverEntityType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32));
this.serverEntityType.AddStructuralProperty("Address", new EdmComplexTypeReference(addressType, true));
// open entity type
this.serverOpenEntityType = new EdmEntityType("Server.NS", "ServerOpenEntityType",
baseType: null, isAbstract: false, isOpen: true);
this.serverModel.AddElement(this.serverOpenEntityType);
this.serverOpenEntityType.AddKeys(this.serverOpenEntityType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32));
this.serverOpenEntityType.AddStructuralProperty("Address", new EdmComplexTypeReference(addressType, true));
EdmEntityContainer container = new EdmEntityContainer("Server.NS", "container1");
this.serverEntitySet = container.AddEntitySet("serverEntitySet", this.serverEntityType);
this.serverOpenEntitySet = container.AddEntitySet("serverOpenEntitySet", this.serverOpenEntityType);
this.serverModel.AddElement(container);
}
public void VerifyAnnotationComputedConcurrency()
{
var model = new EdmModel();
var entity = new EdmEntityType("NS1", "Product");
var entityId = entity.AddStructuralProperty("Id", EdmCoreModel.Instance.GetInt32(false));
entity.AddKeys(entityId);
EdmStructuralProperty name1 = entity.AddStructuralProperty("Name", EdmCoreModel.Instance.GetString(false));
EdmStructuralProperty timeVer = entity.AddStructuralProperty("UpdatedTime", EdmCoreModel.Instance.GetDate(false));
model.AddElement(entity);
SetComputedAnnotation(model, entityId); // semantic meaning is V3's 'Identity' for Key profperty
SetComputedAnnotation(model, timeVer); // semantic meaning is V3's 'Computed' for non-key profperty
var entityContainer = new EdmEntityContainer("NS1", "Container");
model.AddElement(entityContainer);
EdmEntitySet set1 = new EdmEntitySet(entityContainer, "Products", entity);
model.SetOptimisticConcurrencyAnnotation(set1, new IEdmStructuralProperty[] { entityId, timeVer });
entityContainer.AddElement(set1);
string csdlStr = GetEdmx(model, EdmxTarget.OData);
Assert.AreEqual(@"<?xml version=""1.0"" encoding=""utf-16""?><edmx:Edmx Version=""4.0"" xmlns:edmx=""http://docs.oasis-open.org/odata/ns/edmx""><edmx:DataServices><Schema Namespace=""NS1"" xmlns=""http://docs.oasis-open.org/odata/ns/edm""><EntityType Name=""Product""><Key><PropertyRef Name=""Id"" /></Key><Property Name=""Id"" Type=""Edm.Int32"" Nullable=""false""><Annotation Term=""Org.OData.Core.V1.Computed"" Bool=""true"" /></Property><Property Name=""Name"" Type=""Edm.String"" Nullable=""false"" /><Property Name=""UpdatedTime"" Type=""Edm.Date"" Nullable=""false""><Annotation Term=""Org.OData.Core.V1.Computed"" Bool=""true"" /></Property></EntityType><EntityContainer Name=""Container""><EntitySet Name=""Products"" EntityType=""NS1.Product""><Annotation Term=""Org.OData.Core.V1.OptimisticConcurrency""><Collection><PropertyPath>Id</PropertyPath><PropertyPath>UpdatedTime</PropertyPath></Collection></Annotation></EntitySet></EntityContainer></Schema></edmx:DataServices></edmx:Edmx>", csdlStr);
}
private static IEdmModel GetEdmModel()
{
EdmModel _builder = new EdmModel();
// Create Car Entity
EdmEntityType car = new EdmEntityType("Part12.Models", "Car");
car.AddKeys(car.AddStructuralProperty("Make", EdmPrimitiveTypeKind.String), car.AddStructuralProperty("Model", EdmPrimitiveTypeKind.String));
car.AddStructuralProperty("Colour", EdmPrimitiveTypeKind.String);
car.AddStructuralProperty("Price", EdmPrimitiveTypeKind.Double);
var cat = car.AddStructuralProperty("Category", EdmPrimitiveTypeKind.String, false);
_builder.AddAlternateKeyAnnotation(car, new Dictionary <string, IEdmProperty>
{
{ "Category", cat }
});
_builder.AddElement(car);
// Create Container
EdmEntityContainer container = new EdmEntityContainer("default", "Container");
// Add the Cars Entity into the Container
EdmEntitySet cars = container.AddEntitySet("Cars", car);
_builder.AddElement(container);
return(_builder);
}
public void Init()
{
this.clientEdmModel = new ClientEdmModel(ODataProtocolVersion.V4);
this.entityDescriptor = new EntityDescriptor(this.clientEdmModel)
{
Entity = new Customer()
};
var serverType = new EdmEntityType("FQ.NS", "MyServerType");
serverType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo {
Name = "Navigation", Target = serverType, TargetMultiplicity = EdmMultiplicity.ZeroOrOne
});
this.serverTypeName = ((IEdmSchemaElement)serverType).FullName();
var serverContainer = new EdmEntityContainer("FQ.NS", "MyContainer");
this.serverEntitySet = serverContainer.AddEntitySet("MyEntitySet", serverType);
var serverModel = new EdmModel();
serverModel.AddElement(serverType);
serverModel.AddElement(serverContainer);
this.ctx = new DataServiceContext(new Uri("http://temp.org/"), ODataProtocolVersion.V4, this.clientEdmModel);
this.ctx.Format.UseJson(serverModel);
this.testSubject = new RequestInfo(ctx);
}
public void GetModel(EdmModel model, EdmEntityContainer container)
{
EdmEntityType product = new EdmEntityType("ns", "Product");
product.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String);
EdmStructuralProperty key = product.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32);
product.AddKeys(key);
model.AddElement(product);
EdmEntitySet products = container.AddEntitySet("Products", product);
EdmEntityType detailInfo = new EdmEntityType("ns", "DetailInfo");
detailInfo.AddKeys(detailInfo.AddStructuralProperty("ID", EdmPrimitiveTypeKind.Int32));
detailInfo.AddStructuralProperty("Title", EdmPrimitiveTypeKind.String);
model.AddElement(detailInfo);
EdmEntitySet detailInfos = container.AddEntitySet("DetailInfos", product);
EdmNavigationProperty detailInfoNavProp = product.AddUnidirectionalNavigation(
new EdmNavigationPropertyInfo
{
Name = "DetailInfo",
TargetMultiplicity = EdmMultiplicity.One,
Target = detailInfo
});
products.AddNavigationTarget(detailInfoNavProp, detailInfos);
}
public void ReadingNullValueForDynamicCollectionPropertyInOpenStructuralTypeShouldWork()
{
EdmModel model = new EdmModel();
EdmComplexType complexType = new EdmComplexType("NS", "Address", null, false, true);
complexType.AddStructuralProperty("CountryRegion", EdmPrimitiveTypeKind.String);
model.AddElement(complexType);
EdmEntityType entityType = new EdmEntityType("NS", "Person", null, false, true);
entityType.AddKeys(entityType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32));
entityType.AddStructuralProperty("Address", new EdmComplexTypeReference(complexType, false));
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]\":\"#Collection(Edm.String)\"," +
"\"Test\":null," +
"\"Address\":{\"CountryRegion\":\"China\",\"[email protected]\":\"#Collection(Edm.Int32)\",\"Test1\":null}" +
"}";
ODataEntry entry = null;
this.ReadEntryPayload(model, payload, entitySet, entityType, reader => { entry = entry ?? reader.Item as ODataEntry; });
}
public void ReadingNullValueForDeclaredCollectionPropertyInComplexTypeShouldFail()
{
EdmModel model = new EdmModel();
EdmComplexType complexType = new EdmComplexType("NS", "Address");
complexType.AddStructuralProperty("CountriesOrRegions", new EdmCollectionTypeReference(new EdmCollectionType(EdmCoreModel.Instance.GetString(true))));
model.AddElement(complexType);
EdmEntityType entityType = new EdmEntityType("NS", "Person");
entityType.AddKeys(entityType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32));
entityType.AddStructuralProperty("Address", new EdmComplexTypeReference(complexType, true));
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," +
"\"Address\":{\"CountriesOrRegions\":null}" +
"}";
Action read = () => this.ReadEntryPayload(model, payload, entitySet, entityType, reader => { });
read.ShouldThrow <ODataException>().WithMessage("A null value was found for the property named 'CountriesOrRegions', which has the expected type 'Collection(Edm.String)[Nullable=False]'. The expected type 'Collection(Edm.String)[Nullable=False]' does not allow null values.");
}
public void ReadingTypeDefinitionPayloadWithIncompatibleEdmTypeShouldFail()
{
EdmModel model = new EdmModel();
EdmEntityType entityType = new EdmEntityType("NS", "Person");
entityType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32);
EdmTypeDefinition weightType = new EdmTypeDefinition("NS", "Weight", EdmPrimitiveTypeKind.Double);
entityType.AddStructuralProperty("Height", EdmPrimitiveTypeKind.Int32);
model.AddElement(weightType);
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]\":\"#NS.Weight\"," +
"\"Height\":180" +
"}";
Action read = () => this.ReadEntryPayload(model, payload, entitySet, entityType, reader => { });
read.ShouldThrow <ODataException>().WithMessage(Strings.ValidationUtils_IncompatibleType("NS.Weight", "Edm.Int32"));
}
static ODataFeedAndEntryTypeContextTests()
{
Model = new EdmModel();
EntitySetElementType = new EdmEntityType("ns", "Customer");
ExpectedEntityType = new EdmEntityType("ns", "VipCustomer", EntitySetElementType);
ActualEntityType = new EdmEntityType("ns", "DerivedVipCustomer", ExpectedEntityType);
EdmEntityContainer defaultContainer = new EdmEntityContainer("ns", "DefaultContainer");
Model.AddElement(defaultContainer);
Model.AddVocabularyAnnotation(new EdmAnnotation(defaultContainer, UrlConventionsConstants.ConventionTerm, UrlConventionsConstants.KeyAsSegmentAnnotationValue));
EntitySet = new EdmEntitySet(defaultContainer, "Customers", EntitySetElementType);
Model.AddElement(EntitySetElementType);
Model.AddElement(ExpectedEntityType);
Model.AddElement(ActualEntityType);
defaultContainer.AddElement(EntitySet);
SerializationInfo = new ODataFeedAndEntrySerializationInfo {
NavigationSourceName = "MyCustomers", NavigationSourceEntityTypeName = "ns.MyCustomer", ExpectedTypeName = "ns.MyVipCustomer"
};
SerializationInfoWithEdmUnknowEntitySet = new ODataFeedAndEntrySerializationInfo()
{
NavigationSourceName = null, NavigationSourceEntityTypeName = "ns.MyCustomer", ExpectedTypeName = "ns.MyVipCustomer", NavigationSourceKind = EdmNavigationSourceKind.UnknownEntitySet
};
TypeContextWithoutModel = ODataFeedAndEntryTypeContext.Create(SerializationInfo, navigationSource: null, navigationSourceEntityType: null, expectedEntityType: null, model: Model, throwIfMissingTypeInfo: true);
TypeContextWithModel = ODataFeedAndEntryTypeContext.Create(/*serializationInfo*/ null, EntitySet, EntitySetElementType, ExpectedEntityType, Model, throwIfMissingTypeInfo: true);
TypeContextWithEdmUnknowEntitySet = ODataFeedAndEntryTypeContext.Create(SerializationInfoWithEdmUnknowEntitySet, navigationSource: null, navigationSourceEntityType: null, expectedEntityType: null, model: Model, throwIfMissingTypeInfo: true);
BaseTypeContextThatThrows = ODataFeedAndEntryTypeContext.Create(serializationInfo: null, navigationSource: null, navigationSourceEntityType: null, expectedEntityType: null, model: Model, throwIfMissingTypeInfo: true);
BaseTypeContextThatWillNotThrow = ODataFeedAndEntryTypeContext.Create(serializationInfo: null, navigationSource: null, navigationSourceEntityType: null, expectedEntityType: null, model: Model, throwIfMissingTypeInfo: false);
}
public ExpandAndSelectPathExtractingTests()
{
this.baseType = new EdmEntityType("FQ.NS", "Base");
this.baseType.AddKeys(this.baseType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32));
var baseNavigation1 = this.baseType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo {
Name = "Navigation1", Target = this.baseType, TargetMultiplicity = EdmMultiplicity.ZeroOrOne
});
var baseNavigation2 = this.baseType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo {
Name = "Navigation2", Target = this.baseType, TargetMultiplicity = EdmMultiplicity.ZeroOrOne
});
this.derivedType = new EdmEntityType("FQ.NS", "Derived", this.baseType);
this.derivedType.AddStructuralProperty("Derived", EdmPrimitiveTypeKind.Int32);
var derivedNavigation = this.derivedType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo {
Name = "DerivedNavigation", Target = this.derivedType, TargetMultiplicity = EdmMultiplicity.ZeroOrOne
});
var container = new EdmEntityContainer("FQ.NS", "Container");
this.entitySet = container.AddEntitySet("Entities", this.baseType);
this.entitySet.AddNavigationTarget(baseNavigation1, this.entitySet);
this.entitySet.AddNavigationTarget(baseNavigation2, this.entitySet);
this.entitySet.AddNavigationTarget(derivedNavigation, this.entitySet);
this.model = new EdmModel();
this.model.AddElement(this.baseType);
this.model.AddElement(this.derivedType);
this.model.AddElement(container);
}
public void ReadPayloadThrowExceptionWithConflictBetweenInputformatAndIeee754CompatibleValueForIntDecimal()
{
EdmModel model = new EdmModel();
EdmEntityType entityType = new EdmEntityType("NS", "MyTestEntity");
entityType.AddStructuralProperty("DecimalId", EdmPrimitiveTypeKind.Decimal, false);
model.AddElement(entityType);
EdmEntityContainer container = new EdmEntityContainer("EntityNs", "MyContainer_sub");
EdmEntitySet entitySet = container.AddEntitySet("MyTestEntitySet", entityType);
model.AddElement(container);
const string payload =
"{" +
"\"@odata.context\":\"http://www.example.com/$metadata#EntityNs.MyContainer.MyTestEntitySet/$entity\"," +
"\"@odata.id\":\"http://MyTestEntity\"," +
"\"DecimalId\":78.62" +
"}";
IEdmModel mainModel = TestUtils.WrapReferencedModelsToMainModel("EntityNs", "MyContainer", model);
ODataEntry entry = null;
Action test = () => this.ReadEntryPayload(mainModel, payload, entitySet, entityType, reader => { entry = entry ?? reader.Item as ODataEntry; });
test.ShouldThrow <ODataException>().WithMessage(ODataErrorStrings.ODataJsonReaderUtils_ConflictBetweenInputFormatAndParameter("Edm.Decimal"));
}
private static Dictionary <string, EdmEntitySet> AddEntitySets(this EdmModel model, ODataModelBuilder builder, EdmEntityContainer container, Dictionary <Type, IEdmStructuredType> edmTypeMap)
{
IEnumerable <EntitySetConfiguration> configurations = builder.EntitySets;
// build the entitysets and their annotations
IEnumerable <Tuple <EdmEntitySet, EntitySetConfiguration> > entitySets = AddEntitySets(configurations, container, edmTypeMap);
var entitySetAndAnnotations = entitySets.Select(e => new
{
EntitySet = e.Item1,
Configuration = e.Item2,
Annotations = new
{
LinkBuilder = new EntitySetLinkBuilderAnnotation(e.Item2),
Url = new EntitySetUrlAnnotation {
Url = e.Item2.GetUrl()
}
}
}).ToArray();
// index the entitySets by name
Dictionary <string, EdmEntitySet> edmEntitySetMap = entitySetAndAnnotations.ToDictionary(e => e.EntitySet.Name, e => e.EntitySet);
// apply the annotations
foreach (var iter in entitySetAndAnnotations)
{
EdmEntitySet entitySet = iter.EntitySet;
model.SetAnnotationValue <EntitySetUrlAnnotation>(entitySet, iter.Annotations.Url);
model.SetEntitySetLinkBuilder(entitySet, iter.Annotations.LinkBuilder);
AddNavigationBindings(iter.Configuration, iter.EntitySet, iter.Annotations.LinkBuilder, builder, edmTypeMap, edmEntitySetMap);
}
return(edmEntitySetMap);
}
private static IEdmExpression GetEdmEntitySetExpression(IDictionary <string, EdmNavigationSource> navigationSources, OperationConfiguration operationConfiguration)
{
if (operationConfiguration.NavigationSource != null)
{
EdmNavigationSource navigationSource;
if (navigationSources.TryGetValue(operationConfiguration.NavigationSource.Name, out navigationSource))
{
EdmEntitySet entitySet = navigationSource as EdmEntitySet;
if (entitySet != null)
{
return(new EdmPathExpression(entitySet.Name));
}
}
else
{
throw Error.InvalidOperation(SRResources.EntitySetNotFoundForName, operationConfiguration.NavigationSource.Name);
}
}
else if (operationConfiguration.EntitySetPath != null)
{
return(new EdmPathExpression(operationConfiguration.EntitySetPath));
}
return(null);
}
public void WriteDynamicPropertyOfUIntIsNotSupported()
{
EdmModel model = new EdmModel();
EdmEntityType entityType = new EdmEntityType("NS", "Person", null, false, true);
entityType.AddKeys(entityType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32));
model.AddElement(entityType);
EdmEntityContainer container = new EdmEntityContainer("Ns", "MyContainer");
EdmEntitySet entitySet = container.AddEntitySet("People", entityType);
model.AddElement(container);
ODataResource entry = new ODataResource()
{
TypeName = "NS.Person",
Properties = new[]
{
new ODataProperty {
Name = "Id", Value = 1
},
new ODataProperty {
Name = "Guid", Value = UInt64.MaxValue
}
}
};
Action write = () => this.WriterEntry(model, entry, entitySet, entityType);
write.ShouldThrow <ODataException>().WithMessage("The value of type 'System.UInt64' is not supported and cannot be converted to a JSON representation.");
}
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.NotNull(entry);
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");
}
static CustomInstanceAnnotationAcceptanceTests()
{
Model = new EdmModel();
EntityType = new EdmEntityType("TestNamespace", "TestEntityType");
Model.AddElement(EntityType);
var keyProperty = new EdmStructuralProperty(EntityType, "ID", EdmCoreModel.Instance.GetInt32(false));
EntityType.AddKeys(new IEdmStructuralProperty[] { keyProperty });
EntityType.AddProperty(keyProperty);
var resourceNavigationProperty = EntityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo {
Name = "ResourceNavigationProperty", Target = EntityType, TargetMultiplicity = EdmMultiplicity.ZeroOrOne
});
var resourceSetNavigationProperty = EntityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo {
Name = "ResourceSetNavigationProperty", Target = EntityType, TargetMultiplicity = EdmMultiplicity.Many
});
var defaultContainer = new EdmEntityContainer("TestNamespace", "DefaultContainer");
Model.AddElement(defaultContainer);
EntitySet = new EdmEntitySet(defaultContainer, "TestEntitySet", EntityType);
EntitySet.AddNavigationTarget(resourceNavigationProperty, EntitySet);
EntitySet.AddNavigationTarget(resourceSetNavigationProperty, EntitySet);
defaultContainer.AddElement(EntitySet);
ComplexType = new EdmComplexType("TestNamespace", "TestComplexType");
ComplexType.AddProperty(new EdmStructuralProperty(ComplexType, "StringProperty", EdmCoreModel.Instance.GetString(false)));
Model.AddElement(ComplexType);
}
private static object ConvertResource(ODataMessageReader oDataMessageReader, IEdmTypeReference edmTypeReference,
ODataDeserializerContext readContext)
{
EdmEntitySet tempEntitySet = null;
if (edmTypeReference.IsEntity())
{
IEdmEntityTypeReference entityType = edmTypeReference.AsEntity();
tempEntitySet = new EdmEntitySet(readContext.Model.EntityContainer, "temp",
entityType.EntityDefinition());
}
// TODO: Sam xu, can we use the parameter-less overload
ODataReader resourceReader = oDataMessageReader.CreateODataUriParameterResourceReader(tempEntitySet,
edmTypeReference.ToStructuredType());
object item = resourceReader.ReadResourceOrResourceSet();
ODataResourceWrapper topLevelResource = item as ODataResourceWrapper;
Contract.Assert(topLevelResource != null);
IODataDeserializerProvider deserializerProvider = readContext.Request.GetDeserializerProvider();
ODataResourceDeserializer entityDeserializer =
(ODataResourceDeserializer)deserializerProvider.GetEdmTypeDeserializer(edmTypeReference);
return(entityDeserializer.ReadInline(topLevelResource, edmTypeReference, readContext));
}
public void WriteEntryWithStringEscapeOptionShouldWork()
{
EdmModel model = new EdmModel();
EdmEntityType entityType = new EdmEntityType("NS", "Person");
entityType.AddKeys(entityType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32));
entityType.AddStructuralProperty("Name", EdmPrimitiveTypeKind.String);
model.AddElement(entityType);
EdmEntityContainer container = new EdmEntityContainer("Ns", "MyContainer");
EdmEntitySet entitySet = container.AddEntitySet("People", entityType);
model.AddElement(container);
ODataResource entry = new ODataResource()
{
TypeName = "NS.Person",
Properties = new[]
{
new ODataProperty {
Name = "Id", Value = 1
},
new ODataProperty {
Name = "Name", Value = "и\nя"
}
}
};
// 1. without string escape option
string outputPayload = this.WriterEntry(model, entry, entitySet, entityType, false, null, stringEscapeOption: null);
const string expectedEscapedNonAsciiPayload =
"{" +
"\"@odata.context\":\"http://www.example.com/$metadata#People/$entity\"," +
"\"Id\":1," +
"\"Name\":\"\\u0438\\n\\u044f\"" +
"}";
Assert.Equal(expectedEscapedNonAsciiPayload, outputPayload);
// 2. With EscapeNonAscii escape option
outputPayload = this.WriterEntry(model, entry, entitySet, entityType, false, null, ODataStringEscapeOption.EscapeNonAscii);
Assert.Equal(expectedEscapedNonAsciiPayload, outputPayload);
// 3. With EscapeOnlyControls escape option
outputPayload = this.WriterEntry(model, entry, entitySet, entityType,
false, null, ODataStringEscapeOption.EscapeOnlyControls);
const string expectedEscapedOnlyControlPayload =
"{" +
"\"@odata.context\":\"http://www.example.com/$metadata#People/$entity\"," +
"\"Id\":1," +
"\"Name\":\"и\\nя\"" +
"}";
Assert.Equal(expectedEscapedOnlyControlPayload, outputPayload);
}
private static EntitySetSegmentTemplate GetSegmentTemplate(out EdmEntitySet entitySet)
{
EdmEntityType entityType = new EdmEntityType("NS", "entity");
EdmEntityContainer container = new EdmEntityContainer("NS", "default");
entitySet = new EdmEntitySet(container, "entities", entityType);
return(new EntitySetSegmentTemplate(entitySet));
}
internal void AddEntitySet(string entitySetName, ResourceSetWrapper resourceSet)
{
IEdmEntityType elementType = (IEdmEntityType)this.model.EnsureSchemaType(resourceSet.ResourceType);
IEdmEntitySet target = new EdmEntitySet(this, entitySetName, elementType);
MetadataProviderUtils.ConvertCustomAnnotations(this.model, resourceSet.CustomAnnotations, target);
this.entitySetCache.Add(entitySetName, target);
}
public void GetEntitySetLinkBuilder_ReturnsDefaultEntitySetBuilder_IfNotSet()
{
IEdmModel model = new EdmModel();
EdmEntityContainer container = new EdmEntityContainer("NS", "Container");
EdmEntityType entityType = new EdmEntityType("NS", "Entity");
IEdmEntitySet entitySet = new EdmEntitySet(container, "EntitySet", entityType);
Assert.NotNull(model.GetEntitySetLinkBuilder(entitySet));
}
private void InitializeEdmModel()
{
this.edmModel = new EdmModel();
EdmEntityContainer defaultContainer = new EdmEntityContainer("TestModel", "DefaultContainer");
this.edmModel.AddElement(defaultContainer);
EdmComplexType addressType = new EdmComplexType("TestModel", "Address");
addressType.AddStructuralProperty("Street", EdmCoreModel.Instance.GetString(/*isNullable*/ false));
addressType.AddStructuralProperty("Zip", EdmCoreModel.Instance.GetString(/*isNullable*/ false));
this.cityType = new EdmEntityType("TestModel", "City");
EdmStructuralProperty cityIdProperty = cityType.AddStructuralProperty("Id", EdmCoreModel.Instance.GetInt32(/*isNullable*/ false));
cityType.AddKeys(cityIdProperty);
cityType.AddStructuralProperty("Name", EdmCoreModel.Instance.GetString(/*isNullable*/ false));
cityType.AddStructuralProperty("Size", EdmCoreModel.Instance.GetInt32(/*isNullable*/ false));
cityType.AddStructuralProperty("Restaurants", EdmCoreModel.GetCollection(EdmCoreModel.Instance.GetString(/*isNullable*/ false)));
cityType.AddStructuralProperty("Address", new EdmComplexTypeReference(addressType, true));
this.edmModel.AddElement(cityType);
this.capitolCityType = new EdmEntityType("TestModel", "CapitolCity", cityType);
capitolCityType.AddStructuralProperty("CapitolType", EdmCoreModel.Instance.GetString(/*isNullable*/ false));
this.edmModel.AddElement(capitolCityType);
EdmEntityType districtType = new EdmEntityType("TestModel", "District");
EdmStructuralProperty districtIdProperty = districtType.AddStructuralProperty("Id", EdmCoreModel.Instance.GetInt32(/*isNullable*/ false));
districtType.AddKeys(districtIdProperty);
districtType.AddStructuralProperty("Name", EdmCoreModel.Instance.GetString(/*isNullable*/ false));
districtType.AddStructuralProperty("Zip", EdmCoreModel.Instance.GetInt32(/*isNullable*/ false));
this.edmModel.AddElement(districtType);
cityType.AddBidirectionalNavigation(
new EdmNavigationPropertyInfo {
Name = "Districts", Target = districtType, TargetMultiplicity = EdmMultiplicity.Many
},
new EdmNavigationPropertyInfo {
Name = "City", Target = cityType, TargetMultiplicity = EdmMultiplicity.One
});
cityType.NavigationProperties().Single(np => np.Name == "Districts");
capitolCityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo {
Name = "CapitolDistrict", Target = districtType, TargetMultiplicity = EdmMultiplicity.One
});
capitolCityType.AddUnidirectionalNavigation(new EdmNavigationPropertyInfo {
Name = "OutlyingDistricts", Target = districtType, TargetMultiplicity = EdmMultiplicity.Many
});
this.citySet = defaultContainer.AddEntitySet("Cities", cityType);
defaultContainer.AddEntitySet("Districts", districtType);
this.singletonCity = defaultContainer.AddSingleton("SingletonCity", cityType);
}
static ODataReaderExtensionsTests()
{
Model = new EdmModel();
// Address
EdmComplexType address = new EdmComplexType("NS", "Address");
address.AddStructuralProperty("Street", EdmCoreModel.Instance.GetString(false));
Model.AddElement(address);
// Customer
EdmEntityType customer = new EdmEntityType("NS", "Customer");
Model.AddElement(customer);
customer.AddKeys(customer.AddStructuralProperty("CustomerID", EdmCoreModel.Instance.GetInt32(false)));
customer.AddStructuralProperty("Name", EdmCoreModel.Instance.GetString(true));
customer.AddStructuralProperty("Location", new EdmComplexTypeReference(address, false));
// Order
EdmEntityType order = new EdmEntityType("NS", "Order");
Model.AddElement(order);
order.AddKeys(order.AddStructuralProperty("OrderId", EdmCoreModel.Instance.GetInt32(false)));
order.AddStructuralProperty("Price", EdmCoreModel.Instance.GetInt32(false));
// VipOrder
EdmEntityType vipOrder = new EdmEntityType("NS", "VipOrder", order);
Model.AddElement(vipOrder);
vipOrder.AddKeys(vipOrder.AddStructuralProperty("Email", EdmCoreModel.Instance.GetString(false)));
var orderNav = customer.AddUnidirectionalNavigation(
new EdmNavigationPropertyInfo
{
Name = "Order",
Target = order,
TargetMultiplicity = EdmMultiplicity.ZeroOrOne
});
var ordresNav = customer.AddUnidirectionalNavigation(
new EdmNavigationPropertyInfo
{
Name = "Orders",
Target = order,
TargetMultiplicity = EdmMultiplicity.Many
});
EdmEntityContainer defaultContainer = new EdmEntityContainer("NS", "Container");
Model.AddElement(defaultContainer);
EdmEntitySet customers = defaultContainer.AddEntitySet("Customers", customer);
EdmEntitySet orders = defaultContainer.AddEntitySet("Orders", order);
customers.AddNavigationTarget(orderNav, orders);
customers.AddNavigationTarget(ordresNav, orders);
}
public void WriteUIntPayloadShouldWork()
{
EdmModel model = new EdmModel();
EdmEntityType entityType = new EdmEntityType("NS", "Person");
entityType.AddKeys(entityType.AddStructuralProperty("Id", EdmPrimitiveTypeKind.Int32));
entityType.AddStructuralProperty("Guid", model.GetUInt64("NS", false));
model.AddElement(entityType);
EdmEntityContainer container = new EdmEntityContainer("Ns", "MyContainer");
EdmEntitySet entitySet = container.AddEntitySet("People", entityType);
model.AddElement(container);
ODataResource entry = new ODataResource()
{
TypeName = "NS.Person",
Properties = new[]
{
new ODataProperty {
Name = "Id", Value = 1
},
new ODataProperty {
Name = "Guid", Value = UInt64.MaxValue
}
}
};
string outputPayload = this.WriterEntry(model, entry, entitySet, entityType);
const string expectedMinimalPayload =
"{" +
"\"@odata.context\":\"http://www.example.com/$metadata#People/$entity\"," +
"\"Id\":1," +
"\"Guid\":18446744073709551615" +
"}";
Assert.Equal(expectedMinimalPayload, outputPayload);
outputPayload = this.WriterEntry(model, entry, entitySet, entityType, true);
const string expectedFullPayload =
"{" +
"\"@odata.context\":\"http://www.example.com/$metadata#People/$entity\"," +
"\"@odata.type\":\"#NS.Person\"," +
"\"@odata.id\":\"People(1)\"," +
"\"@odata.editLink\":\"People(1)\"," +
"\"Id\":1," +
"\"Guid\":18446744073709551615" +
"}";
Assert.Equal(expectedFullPayload, outputPayload);
}
private static object ConvertResourceSet(ODataMessageReader oDataMessageReader,
IEdmTypeReference edmTypeReference, ODataDeserializerContext readContext)
{
IEdmCollectionTypeReference collectionType = edmTypeReference.AsCollection();
EdmEntitySet tempEntitySet = null;
if (collectionType.ElementType().IsEntity())
{
tempEntitySet = new EdmEntitySet(readContext.Model.EntityContainer, "temp",
collectionType.ElementType().AsEntity().EntityDefinition());
}
// TODO: Sam xu, can we use the parameter-less overload
ODataReader odataReader = oDataMessageReader.CreateODataUriParameterResourceSetReader(tempEntitySet,
collectionType.ElementType().AsStructured().StructuredDefinition());
ODataResourceSetWrapper resourceSet =
odataReader.ReadResourceOrResourceSet() as ODataResourceSetWrapper;
ODataDeserializerProvider deserializerProvider = readContext.Request.GetDeserializerProvider();
ODataResourceSetDeserializer resourceSetDeserializer =
(ODataResourceSetDeserializer)deserializerProvider.GetEdmTypeDeserializer(collectionType);
object result = resourceSetDeserializer.ReadInline(resourceSet, collectionType, readContext);
IEnumerable enumerable = result as IEnumerable;
if (enumerable != null)
{
IEnumerable newEnumerable = enumerable;
if (collectionType.ElementType().IsEntity())
{
newEnumerable = CovertResourceSetIds(enumerable, resourceSet, collectionType, readContext);
}
if (readContext.IsUntyped)
{
return(newEnumerable.ConvertToEdmObject(collectionType));
}
else
{
IEdmTypeReference elementTypeReference = collectionType.ElementType();
Type elementClrType = EdmLibHelpers.GetClrType(elementTypeReference,
readContext.Model);
IEnumerable castedResult =
CastMethodInfo.MakeGenericMethod(elementClrType)
.Invoke(null, new object[] { newEnumerable }) as IEnumerable;
return(castedResult);
}
}
return(null);
}
public ODataAtomReaderEnumIntegrationTests()
{
this.userModel = 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));
this.userModel.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));
this.userModel.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)));
this.userModel.AddElement(myComplexType);
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.entitySet = new EdmEntitySet(defaultContainer, "MySet", this.entityType);
defaultContainer.AddEntitySet(this.entitySet.Name, this.entityType);
this.userModel.AddElement(defaultContainer);
}
public void TestEntityType()
{
var container = new EdmEntityContainer("NS", "C");
var entityType = new EdmEntityType("NS", "People");
var entitySet = new EdmEntitySet(container, "Peoples", entityType);
Assert.AreEqual(entityType, entitySet.EntityType());
var singleton = new EdmSingleton(container, "Boss", entityType);
Assert.AreEqual(entityType, singleton.EntityType());
}
internal void WriteAssociationSetEndElement(EdmEntitySet end, string roleName)
{
_xmlWriter.WriteStartElement(CsdlConstants.Element_End);
_xmlWriter.WriteAttributeString(CsdlConstants.Attribute_Role, roleName);
_xmlWriter.WriteAttributeString(CsdlConstants.Attribute_EntitySet, end.Name);
_xmlWriter.WriteEndElement();
}
protected virtual void VisitEdmAssociationSetEnd(EdmEntitySet item)
{
VisitEdmNamedMetadataItem(item);
}
protected virtual void VisitEdmEntitySet(EdmEntitySet item)
{
VisitEdmNamedMetadataItem(item);
}
internal void WriteEntitySetElementHeader(EdmEntitySet entitySet)
{
_xmlWriter.WriteStartElement(CsdlConstants.Element_EntitySet);
_xmlWriter.WriteAttributeString(CsdlConstants.Attribute_Name, entitySet.Name);
_xmlWriter.WriteAttributeString(
CsdlConstants.Attribute_EntityType,
GetQualifiedTypeName(CsdlConstants.Value_Self, entitySet.ElementType.Name));
}
protected override void VisitEdmEntitySet(EdmEntitySet item)
{
_schemaWriter.WriteEntitySetElementHeader(item);
base.VisitEdmEntitySet(item);
_schemaWriter.WriteEndElement();
}
