public async Task ReferentialConstraintModelBuilderTest(string modelMode)
{
string requestUri = string.Format("{0}/{1}/$metadata", this.BaseAddress, modelMode);
HttpResponseMessage response = await this.Client.GetAsync(requestUri);
var stream = await response.Content.ReadAsStreamAsync();
IODataResponseMessage message = new ODataMessageWrapper(stream, response.Content.Headers);
var reader = new ODataMessageReader(message);
var edmModel = reader.ReadMetadataDocument();
var customer = edmModel.SchemaElements.OfType<IEdmEntityType>()
.Single(et => et.Name == "ForeignKeyCustomer");
Assert.Equal(3, customer.Properties().Count());
var order = edmModel.SchemaElements.OfType<IEdmEntityType>().Single(et => et.Name == "ForeignKeyOrder");
Assert.Equal(4, order.Properties().Count());
var customerIdProperty = order.DeclaredProperties.Single(p => p.Name == "CustomerId");
var navProperty = order.DeclaredNavigationProperties().Single(p => p.Name == "Customer");
Assert.Equal(EdmOnDeleteAction.Cascade, navProperty.OnDelete);
Assert.Equal(1, navProperty.DependentProperties.Count());
var dependentProperty = navProperty.DependentProperties.Single();
Assert.Same(customerIdProperty, dependentProperty);
}
public async Task ModelBuilderTest(string modelMode)
{
string requestUri = string.Format("{0}/{1}/$metadata", this.BaseAddress, modelMode);
HttpResponseMessage response = await this.Client.GetAsync(requestUri);
var stream = await response.Content.ReadAsStreamAsync();
IODataResponseMessage message = new ODataMessageWrapper(stream, response.Content.Headers);
var reader = new ODataMessageReader(message);
var edmModel = reader.ReadMetadataDocument();
var fileType = edmModel.SchemaElements.OfType<IEdmEntityType>().Single(et => et.Name == "File");
Assert.Equal(5, fileType.Properties().Count());
var createdDateProperty = fileType.DeclaredProperties.Single(p => p.Name == "CreatedDate");
Assert.Equal(EdmTypeKind.Primitive, createdDateProperty.Type.TypeKind());
Assert.Equal("Edm.DateTimeOffset", createdDateProperty.Type.Definition.FullTypeName());
Assert.False(createdDateProperty.Type.IsNullable);
var deleteDateProperty = fileType.DeclaredProperties.Single(p => p.Name == "DeleteDate");
Assert.Equal(EdmTypeKind.Primitive, deleteDateProperty.Type.TypeKind());
Assert.Equal("Edm.DateTimeOffset", deleteDateProperty.Type.Definition.FullTypeName());
Assert.True(deleteDateProperty.Type.IsNullable);
var modifiedDates = fileType.DeclaredProperties.Single(p => p.Name == "ModifiedDates");
Assert.Equal(EdmTypeKind.Collection, modifiedDates.Type.TypeKind());
Assert.Equal("Collection(Edm.DateTimeOffset)", modifiedDates.Type.Definition.FullTypeName());
Assert.False(modifiedDates.Type.IsNullable);
}
public async Task ModelBuilderTest()
{
string requestUri = string.Format("{0}/odata/$metadata", this.BaseAddress);
HttpResponseMessage response = await this.Client.GetAsync(requestUri);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
var stream = await response.Content.ReadAsStreamAsync();
IODataResponseMessage message = new ODataMessageWrapper(stream, response.Content.Headers);
var reader = new ODataMessageReader(message);
var edmModel = reader.ReadMetadataDocument();
var container = edmModel.EntityContainer;
Assert.Equal("Container", container.Name);
var employeeType = edmModel.SchemaElements.Single(e => e.Name == "Employee") as IEdmEntityType;
employeeType.Properties().All(p => this.IsCamelCase(p.Name));
var managerType = edmModel.SchemaElements.Single(e => e.Name == "Manager") as IEdmEntityType;
Assert.Equal(7, managerType.Properties().Count());
managerType.Properties().All(p => this.IsCamelCase(p.Name));
var addressType = edmModel.SchemaElements.Single(e => e.Name == "Address") as IEdmComplexType;
addressType.Properties().All(p => this.IsCamelCase(p.Name));
}
public async Task VerifyMetaDataIsGeneratedCorrectly()
{
var response = await Client.GetAsync(BaseAddress + "/$metadata");
var stream = await response.Content.ReadAsStreamAsync();
IODataResponseMessage message = new ODataMessageWrapper(stream, response.Content.Headers);
var reader = new ODataMessageReader(message);
var edmModel = reader.ReadMetadataDocument();
Assert.Equal(4, edmModel.GetEdmVersion().Major);
var container = edmModel.EntityContainer;
Assert.Equal("Container", container.Name);
Assert.Equal(3, container.Elements.Count());
var address = edmModel.SchemaElements.OfType <IEdmComplexType>().First();
Assert.Equal("Address", address.Name);
Assert.Equal(5, address.Properties().Count());
var product = edmModel.SchemaElements.Where(e => e.Name == "Product").First() as IEdmEntityType;
Assert.Equal(1, product.Key().Count());
Assert.Equal("ID", product.Key().First().Name);
Assert.Equal(5, product.Properties().Count());
var supplier = edmModel.SchemaElements.Where(e => e.Name == "Supplier").First() as IEdmEntityType;
Assert.Equal(1, supplier.Key().Count());
Assert.Equal("ID", supplier.Key().First().Name);
Assert.Equal(6, supplier.Properties().Count());
var addressesProperty = supplier.Properties().First(p => p.Name == "Addresses").Type.AsCollection();
Assert.Equal(typeof(Address).FullName, addressesProperty.CollectionDefinition().ElementType.FullName());
// [ODATA-CSDL]
// In 6.2.1
// a) If not value is specified for a property whose Type attribute does not specify a collection,
// the Nuallable attribute defaults to true
// b) A property whose Type attribute specifies a collection MUST NOT specify a value for the
// Nullable attribute as the collection always exists, it may just be empty.
Assert.Equal(true, addressesProperty.IsNullable);
var tagsProperty = supplier.Properties().First(p => p.Name == "Tags").Type.AsCollection();
Assert.Equal("Edm.String", tagsProperty.CollectionDefinition().ElementType.FullName());
Assert.Equal(true, tagsProperty.IsNullable);
}
public void VerifyMetaDataIsGeneratedCorrectly()
{
var response = this.Client.GetAsync(this.BaseAddress + "/$metadata").Result;
var stream = response.Content.ReadAsStreamAsync().Result;
IODataResponseMessage message = new ODataMessageWrapper(stream, response.Content.Headers);
var reader = new ODataMessageReader(message);
var edmModel = reader.ReadMetadataDocument();
Assert.Equal(3, edmModel.GetEdmVersion().Major);
Assert.Equal(3, edmModel.GetMaxDataServiceVersion().Major);
Assert.Equal(1, edmModel.EntityContainers().Count());
var container = edmModel.EntityContainers().First();
Assert.Equal("Container", container.Name);
Assert.Equal(3, container.Elements.Count());
var address = edmModel.SchemaElements.OfType <IEdmComplexType>().First();
Assert.Equal("Address", address.Name);
Assert.Equal(5, address.Properties().Count());
var product = edmModel.SchemaElements.Where(e => e.Name == "Product").First() as IEdmEntityType;
Assert.Equal(1, product.Key().Count());
Assert.Equal("ID", product.Key().First().Name);
Assert.Equal(5, product.Properties().Count());
var supplier = edmModel.SchemaElements.Where(e => e.Name == "Supplier").First() as IEdmEntityType;
Assert.Equal(1, supplier.Key().Count());
Assert.Equal("ID", supplier.Key().First().Name);
Assert.Equal(6, supplier.Properties().Count());
var addressesProperty = supplier.Properties().First(p => p.Name == "Addresses").Type.AsCollection();
Assert.Equal(typeof(Address).FullName, addressesProperty.CollectionDefinition().ElementType.FullName());
Assert.Equal(false, addressesProperty.IsNullable);
var tagsProperty = supplier.Properties().First(p => p.Name == "Tags").Type.AsCollection();
Assert.Equal("Edm.String", tagsProperty.CollectionDefinition().ElementType.FullName());
Assert.Equal(false, tagsProperty.IsNullable);
}
public void ModelBuilderTest()
{
const string expectMetadata =
" <EntitySet Name=\"ETagUntypedCustomers\" EntityType=\"NS.Customer\">\r\n" +
" <Annotation Term=\"Org.OData.Core.V1.OptimisticConcurrency\">\r\n" +
" <Collection>\r\n" +
" <PropertyPath>Name</PropertyPath>\r\n" +
" </Collection>\r\n" +
" </Annotation>\r\n" +
" </EntitySet>";
string requestUri = string.Format("{0}/odata/$metadata", this.BaseAddress);
HttpResponseMessage response = this.Client.GetAsync(requestUri).Result;
var content = response.Content.ReadAsStringAsync().Result;
Assert.Contains(expectMetadata, content);
var stream = response.Content.ReadAsStreamAsync().Result;
IODataResponseMessage message = new ODataMessageWrapper(stream, response.Content.Headers);
var reader = new ODataMessageReader(message);
var edmModel = reader.ReadMetadataDocument();
Assert.NotNull(edmModel);
var etagCustomers = edmModel.FindDeclaredEntitySet("ETagUntypedCustomers");
Assert.NotNull(etagCustomers);
var annotations = edmModel.FindDeclaredVocabularyAnnotations(etagCustomers);
IEdmVocabularyAnnotation annotation = Assert.Single(annotations);
Assert.NotNull(annotation);
Assert.Same(CoreVocabularyModel.ConcurrencyTerm, annotation.Term);
Assert.Same(etagCustomers, annotation.Target);
IEdmValueAnnotation valueAnnotation = annotation as IEdmValueAnnotation;
Assert.NotNull(valueAnnotation);
Assert.NotNull(valueAnnotation.Value);
IEdmCollectionExpression collection = valueAnnotation.Value as IEdmCollectionExpression;
Assert.NotNull(collection);
Assert.Equal(new[] { "Name" }, collection.Elements.Select(e => ((IEdmPathExpression) e).Path.Single()));
}
public async Task SpatialModelMetadataTest()
{
string requestUri = string.Format("{0}/odata/$metadata", this.BaseAddress);
HttpResponseMessage response = await this.Client.GetAsync(requestUri);
var stream = await response.Content.ReadAsStreamAsync();
IODataResponseMessage message = new ODataMessageWrapper(stream, response.Content.Headers);
var reader = new ODataMessageReader(message);
var edmModel = reader.ReadMetadataDocument();
var customer = edmModel.SchemaElements.OfType<IEdmEntityType>().Single(et => et.Name == "SpatialCustomer");
Assert.Equal(5, customer.Properties().Count());
var locationProperty = customer.DeclaredProperties.Single(p => p.Name == "Location");
Assert.Equal("Edm.GeographyPoint", locationProperty.Type.FullName());
var regionProperty = customer.DeclaredProperties.Single(p => p.Name == "Region");
Assert.Equal("Edm.GeographyLineString", regionProperty.Type.FullName());
var homePointProperty = customer.DeclaredProperties.Single(p => p.Name == "HomePoint");
Assert.Equal("Edm.GeometryPoint", homePointProperty.Type.FullName());
}
public async Task ModelBuilderTest(string modelMode)
{
string requestUri = string.Format("{0}/{1}/$metadata", this.BaseAddress, modelMode);
HttpResponseMessage response = await this.Client.GetAsync(requestUri);
var stream = await response.Content.ReadAsStreamAsync();
IODataResponseMessage message = new ODataMessageWrapper(stream, response.Content.Headers);
var reader = new ODataMessageReader(message);
var edmModel = reader.ReadMetadataDocument();
var customerType = edmModel.SchemaElements.OfType<IEdmEntityType>().Single(et => et.Name == "DCustomer");
Assert.Equal(17, customerType.Properties().Count());
// Non-Nullable
AssertHasProperty(customerType, propertyName: "DateTime", expectKind: EdmTypeKind.Primitive, expectTypeName: "Edm.DateTimeOffset", isNullable: false);
AssertHasProperty(customerType, propertyName: "Offset", expectKind: EdmTypeKind.Primitive, expectTypeName: "Edm.DateTimeOffset", isNullable: false);
AssertHasProperty(customerType, propertyName: "Date", expectKind: EdmTypeKind.Primitive, expectTypeName: "Edm.Date", isNullable: false);
AssertHasProperty(customerType, propertyName: "TimeOfDay", expectKind: EdmTypeKind.Primitive, expectTypeName: "Edm.TimeOfDay", isNullable: false);
// Nullable
AssertHasProperty(customerType, propertyName: "NullableDateTime", expectKind: EdmTypeKind.Primitive, expectTypeName: "Edm.DateTimeOffset", isNullable: true);
AssertHasProperty(customerType, propertyName: "NullableOffset", expectKind: EdmTypeKind.Primitive, expectTypeName: "Edm.DateTimeOffset", isNullable: true);
AssertHasProperty(customerType, propertyName: "NullableDate", expectKind: EdmTypeKind.Primitive, expectTypeName: "Edm.Date", isNullable: true);
AssertHasProperty(customerType, propertyName: "NullableTimeOfDay", expectKind: EdmTypeKind.Primitive, expectTypeName: "Edm.TimeOfDay", isNullable: true);
// Collection
AssertHasProperty(customerType, propertyName: "DateTimes", expectKind: EdmTypeKind.Collection, expectTypeName: "Collection(Edm.DateTimeOffset)", isNullable: false);
AssertHasProperty(customerType, propertyName: "Offsets", expectKind: EdmTypeKind.Collection, expectTypeName: "Collection(Edm.DateTimeOffset)", isNullable: false);
AssertHasProperty(customerType, propertyName: "Dates", expectKind: EdmTypeKind.Collection, expectTypeName: "Collection(Edm.Date)", isNullable: false);
AssertHasProperty(customerType, propertyName: "TimeOfDays", expectKind: EdmTypeKind.Collection, expectTypeName: "Collection(Edm.TimeOfDay)", isNullable: false);
// nullable collection
AssertHasProperty(customerType, propertyName: "NullableDateTimes", expectKind: EdmTypeKind.Collection, expectTypeName: "Collection(Edm.DateTimeOffset)", isNullable: true);
AssertHasProperty(customerType, propertyName: "NullableOffsets", expectKind: EdmTypeKind.Collection, expectTypeName: "Collection(Edm.DateTimeOffset)", isNullable: true);
AssertHasProperty(customerType, propertyName: "NullableDates", expectKind: EdmTypeKind.Collection, expectTypeName: "Collection(Edm.Date)", isNullable: true);
AssertHasProperty(customerType, propertyName: "NullableTimeOfDays", expectKind: EdmTypeKind.Collection, expectTypeName: "Collection(Edm.TimeOfDay)", isNullable: true);
}
public async Task VerifyMetaDataIsGeneratedCorrectly()
{
var response = await Client.GetAsync(this.BaseAddress + "/$metadata");
var stream = await response.Content.ReadAsStreamAsync();
IODataResponseMessage message = new ODataMessageWrapper(stream, response.Content.Headers);
var reader = new ODataMessageReader(message);
var edmModel = reader.ReadMetadataDocument();
Assert.Equal(4, edmModel.GetEdmVersion().Major);
var container = edmModel.EntityContainer;
Assert.Equal("Container", container.Name);
Assert.Equal(3, container.Elements.Count());
var address = edmModel.SchemaElements.OfType<IEdmComplexType>().First();
Assert.Equal("Address", address.Name);
Assert.Equal(5, address.Properties().Count());
var product = edmModel.SchemaElements.Where(e => e.Name == "Product").First() as IEdmEntityType;
Assert.Equal(1, product.Key().Count());
Assert.Equal("ID", product.Key().First().Name);
Assert.Equal(5, product.Properties().Count());
var supplier = edmModel.SchemaElements.Where(e => e.Name == "Supplier").First() as IEdmEntityType;
Assert.Equal(1, supplier.Key().Count());
Assert.Equal("ID", supplier.Key().First().Name);
Assert.Equal(6, supplier.Properties().Count());
var addressesProperty = supplier.Properties().First(p => p.Name == "Addresses").Type.AsCollection();
Assert.Equal(typeof(Address).FullName, addressesProperty.CollectionDefinition().ElementType.FullName());
Assert.Equal(false, addressesProperty.IsNullable);
var tagsProperty = supplier.Properties().First(p => p.Name == "Tags").Type.AsCollection();
Assert.Equal("Edm.String", tagsProperty.CollectionDefinition().ElementType.FullName());
Assert.Equal(true, tagsProperty.IsNullable);
}
public async Task ServiceDocumentTest(string format)
{
// Act
var requestUri = string.Format("{0}/odata?$format={1}", BaseAddress, format);
var response = await Client.GetAsync(requestUri);
var stream = await response.Content.ReadAsStreamAsync();
//Assert
var oDataMessageReaderSettings = new ODataMessageReaderSettings();
IODataResponseMessage message = new ODataMessageWrapper(stream, response.Content.Headers);
var reader = new ODataMessageReader(message, oDataMessageReaderSettings, UnboundFunctionEdmModel.GetEdmModel());
var oDataWorkSpace = reader.ReadServiceDocument();
var function1 = oDataWorkSpace.FunctionImports.Where(odataResourceCollectionInfo => odataResourceCollectionInfo.Name == "GetAllConventionCustomers");
Assert.Equal(1, function1.Count());
var function2 = oDataWorkSpace.FunctionImports.Where(odataResourceCollectionInfo => odataResourceCollectionInfo.Name == "GetConventionOrderByCustomerIdAndOrderName");
// ODL spec says:
// The edm:FunctionImport for a parameterless function MAY include the IncludeInServiceDocument attribute
// whose Boolean value indicates whether the function import is advertised in the service document.
// So the below 2 FunctionImports are not displayed in ServiceDocument.
Assert.Equal(0, function2.Count());
var function3 = oDataWorkSpace.FunctionImports.Where(odataResourceCollectionInfo => odataResourceCollectionInfo.Name == "GetConventionCustomerById");
Assert.Equal(0, function3.Count());
}
public async Task MetaDataTest()
{
// Act
var requestUri = string.Format("{0}/odata/$metadata", BaseAddress);
var response = await Client.GetAsync(requestUri);
var stream = await response.Content.ReadAsStreamAsync();
// Assert
IODataResponseMessage message = new ODataMessageWrapper(stream, response.Content.Headers);
var reader = new ODataMessageReader(message);
var edmModel = reader.ReadMetadataDocument();
#region functions
// Function GetAllConventionCustomers
var typeOfConventionCustomer = typeof(ConventionCustomer);
var function1 = edmModel.FindDeclaredOperations(typeOfConventionCustomer.Namespace + ".GetAllConventionCustomers").FirstOrDefault();
Assert.Equal(string.Format("Collection({0})", typeOfConventionCustomer.FullName), function1.ReturnType.Definition.FullTypeName());
Assert.Equal(0, function1.Parameters.Count());
// Function GetConventionCustomerById
var function2 = edmModel.FindDeclaredOperations(typeof(ConventionCustomer).Namespace + ".GetConventionCustomerById").FirstOrDefault();
Assert.Equal(typeOfConventionCustomer.FullName, function2.ReturnType.Definition.FullTypeName());
Assert.Equal(1, function2.Parameters.Count());
// Function GetConventionOrderByCustomerIdAndOrderName
var typeOfConventionOrder = typeof(ConventionOrder);
var function3 = edmModel.FindDeclaredOperations(typeOfConventionOrder.Namespace + ".GetConventionOrderByCustomerIdAndOrderName").FirstOrDefault();
Assert.Equal(typeOfConventionOrder.FullName, function3.ReturnType.Definition.FullTypeName());
Assert.Equal(2, function3.Parameters.Count());
#endregion
#region function imports
var container = edmModel.EntityContainer;
Assert.Equal("Container", container.Name);
var functionImport1 = container.FindOperationImports("GetAllConventionCustomers");
Assert.Equal(2, functionImport1.Count());
var functionImport2 = container.FindOperationImports("GetConventionCustomerById");
Assert.Equal(1, functionImport2.Count());
var functionImport3 = container.FindOperationImports("GetConventionOrderByCustomerIdAndOrderName");
Assert.Equal(1, functionImport3.Count());
#endregion
#region actions
var action1 = edmModel.FindDeclaredOperations(typeOfConventionCustomer.Namespace + ".ResetDataSource").FirstOrDefault();
Assert.Null(action1.ReturnType);
Assert.Equal(0, function1.Parameters.Count());
var action2 = edmModel.FindDeclaredOperations(typeOfConventionCustomer.Namespace + ".UpdateAddress").FirstOrDefault();
Assert.Equal(string.Format("Collection({0})", typeOfConventionCustomer.FullName), action2.ReturnType.Definition.FullTypeName());
Assert.Equal(2, action2.Parameters.Count());
#endregion
#region action imports
var actionImport1 = container.FindOperationImports("ResetDataSource");
Assert.Equal(1, actionImport1.Count());
var actionImport2 = container.FindOperationImports("UpdateAddress");
Assert.Equal(1, actionImport2.Count());
#endregion
}
public async Task ModelBuilderTest(string modelMode)
{
string requestUri = string.Format("{0}/{1}/$metadata", this.BaseAddress, modelMode);
HttpResponseMessage response = await this.Client.GetAsync(requestUri);
var stream = await response.Content.ReadAsStreamAsync();
IODataResponseMessage message = new ODataMessageWrapper(stream, response.Content.Headers);
var reader = new ODataMessageReader(message);
var edmModel = reader.ReadMetadataDocument();
var accountType = edmModel.SchemaElements.OfType<IEdmEntityType>().Single(et => et.Name == "Account");
Assert.Equal(4, accountType.Properties().Count());
var payinPIs = accountType.NavigationProperties().Single(np => np.Name == "PayinPIs");
Assert.True(payinPIs.ContainsTarget, "The navigation property 'PayinPIs' should be a containment navigation property.");
Assert.Equal(string.Format("Collection({0})", typeof(PaymentInstrument).FullName), payinPIs.Type.Definition.FullTypeName());
var payoutPI = accountType.DeclaredNavigationProperties().Single(np => np.Name == "PayoutPI");
Assert.True(payoutPI.ContainsTarget, "PreminumAccountType.GiftCard");
Assert.Equal(EdmMultiplicity.ZeroOrOne, payoutPI.TargetMultiplicity());
var paymentInstrumentType = edmModel.SchemaElements.OfType<IEdmEntityType>().Single(et => et.Name == "PaymentInstrument");
Assert.Equal(3, paymentInstrumentType.Properties().Count());
var statement = paymentInstrumentType.NavigationProperties().Single(np => np.Name == "Statement");
Assert.True(statement.ContainsTarget, "PaymentInstrumentType.ContainsTarget");
Assert.Equal(EdmMultiplicity.ZeroOrOne, statement.TargetMultiplicity());
var premiumAccountType = edmModel.SchemaElements.OfType<IEdmEntityType>().Single(et => et.Name == "PremiumAccount");
Assert.Equal(1, premiumAccountType.DeclaredProperties.Count());
var giftCard = premiumAccountType.DeclaredProperties.Single() as IEdmNavigationProperty;
Assert.True(giftCard.ContainsTarget, "PreminumAccountType.GiftCard");
Assert.Equal(EdmMultiplicity.One, giftCard.TargetMultiplicity());
var edmNamespace = typeof(PaymentInstrument).Namespace;
var actionClear = edmModel.FindOperations(edmNamespace + ".Clear").Single() as IEdmAction;
var nameContains = actionClear.Parameters.Single(p => p.Name == "nameContains");
Assert.Equal("Edm.String", nameContains.Type.Definition.ToString());
Assert.Equal("Edm.Int32", actionClear.ReturnType.Definition.ToString());
var functionGetCount = edmModel.FindDeclaredOperations(edmNamespace + ".GetCount").Single() as IEdmFunction;
nameContains = functionGetCount.Parameters.Single(p => p.Name == "nameContains");
Assert.Equal("Edm.String", nameContains.Type.Definition.ToString());
Assert.Equal("Edm.Int32", functionGetCount.ReturnType.Definition.ToString());
var container = edmModel.EntityContainer;
Assert.Equal("Container", container.Name);
}
public async Task ModelBuilderTest(string modelMode)
{
string requestUri = string.Format("{0}/{1}/$metadata", this.BaseAddress, modelMode);
HttpResponseMessage response = await this.Client.GetAsync(requestUri);
var stream = await response.Content.ReadAsStreamAsync();
IODataResponseMessage message = new ODataMessageWrapper(stream, response.Content.Headers);
var reader = new ODataMessageReader(message);
var edmModel = reader.ReadMetadataDocument();
var container = edmModel.EntityContainer;
Assert.Equal("Container", container.Name);
var favoriteSports = edmModel.SchemaElements.OfType<IEdmComplexType>().First();
Assert.Equal("FavoriteSports", favoriteSports.Name);
Assert.Equal(2, favoriteSports.Properties().Count());
//ComplexType Enum Property
var likeMost = favoriteSports.Properties().SingleOrDefault(p => p.Name == "LikeMost");
Assert.True(likeMost.Type.IsEnum());
//ComplexType Enum Property
var like = favoriteSports.Properties().SingleOrDefault(p => p.Name == "Like");
Assert.True(like.Type.IsCollection());
var employee = edmModel.SchemaElements.SingleOrDefault(e => e.Name == "Employee") as IEdmEntityType;
Assert.Equal(1, employee.Key().Count());
Assert.Equal("ID", employee.Key().First().Name);
Assert.Equal(6, employee.Properties().Count());
//Entity Enum Collection Property
var skillSet = employee.Properties().SingleOrDefault(p => p.Name == "SkillSet");
Assert.True(skillSet.Type.IsCollection());
//Entity Enum Property
var gender = employee.Properties().SingleOrDefault(p => p.Name == "Gender");
Assert.True(gender.Type.IsEnum());
var edmEnumType = gender.Type.Definition as IEdmEnumType;
Assert.False(edmEnumType.IsFlags);
var accessLevel = employee.Properties().SingleOrDefault(p => p.Name == "AccessLevel") as IEdmStructuralProperty;
edmEnumType = accessLevel.Type.Definition as IEdmEnumType;
Assert.Equal(3, edmEnumType.Members.Count());
Assert.True(edmEnumType.IsFlags);
//Action AddSkill
var iEdmOperation = edmModel.FindOperations(typeof(Employee).Namespace + ".AddSkill").FirstOrDefault();
var iEdmOperationParameter = iEdmOperation.Parameters.SingleOrDefault(p => p.Name == "skill");
var definition = iEdmOperationParameter.Type.Definition;
Assert.Equal(EdmTypeKind.Enum, definition.TypeKind);
var iEdmCollectionTpeReference = iEdmOperation.ReturnType as IEdmCollectionTypeReference;
var iEdmTypeReference = iEdmCollectionTpeReference.ElementType();
Assert.Equal(EdmTypeKind.Enum, iEdmTypeReference.Definition.TypeKind);
// Action SetAccessLevel
var iEdmOperationOfSetAccessLevel = edmModel.FindOperations(typeof(Employee).Namespace + ".SetAccessLevel").FirstOrDefault();
var iEdmOperationParameterOfAccessLevel = iEdmOperationOfSetAccessLevel.Parameters.SingleOrDefault(p => p.Name == "accessLevel");
var definitionOfAccessLevel = iEdmOperationParameterOfAccessLevel.Type.Definition;
Assert.Equal(EdmTypeKind.Enum, definitionOfAccessLevel.TypeKind);
var iEdmTpeReferenceOfAccessLevel = iEdmOperationOfSetAccessLevel.ReturnType;
Assert.Equal(EdmTypeKind.Enum, iEdmTpeReferenceOfAccessLevel.Definition.TypeKind);
// Function GetAccessLevel
var iEdmOperationOfGetAccessLevel = edmModel.FindDeclaredOperations(typeof(Employee).Namespace + ".GetAccessLevel").FirstOrDefault();
var iEdmTypeReferenceOfGetAccessLevel = iEdmOperationOfGetAccessLevel.ReturnType;
Assert.Equal(EdmTypeKind.Enum, iEdmTypeReferenceOfGetAccessLevel.Definition.TypeKind);
// Function HasAccessLevel
var iEdmOperationOfHasAccessLevel = edmModel.FindDeclaredOperations(typeof(Employee).Namespace + ".HasAccessLevel").FirstOrDefault();
var iEdmOperationParameterOfHasAccessLevel = iEdmOperationOfHasAccessLevel.Parameters.SingleOrDefault(p => p.Name == "AccessLevel");
Assert.Equal(EdmTypeKind.Enum, iEdmOperationParameterOfHasAccessLevel.Type.Definition.TypeKind);
}
public void ModelBuilderTest()
{
const string expectMetadata =
" <EntitySet Name=\"ETagsCustomers\" EntityType=\"WebStack.QA.Test.OData.ETags.ETagsCustomer\">\r\n" +
" <Annotation Term=\"Org.OData.Core.V1.OptimisticConcurrency\">\r\n" +
" <Collection>\r\n" +
" <PropertyPath>Id</PropertyPath>\r\n" +
" <PropertyPath>Name</PropertyPath>\r\n" +
" <PropertyPath>BoolProperty</PropertyPath>\r\n" +
" <PropertyPath>ByteProperty</PropertyPath>\r\n" +
" <PropertyPath>CharProperty</PropertyPath>\r\n" +
" <PropertyPath>DecimalProperty</PropertyPath>\r\n" +
" <PropertyPath>DoubleProperty</PropertyPath>\r\n" +
" <PropertyPath>ShortProperty</PropertyPath>\r\n" +
" <PropertyPath>LongProperty</PropertyPath>\r\n" +
" <PropertyPath>SbyteProperty</PropertyPath>\r\n" +
" <PropertyPath>FloatProperty</PropertyPath>\r\n" +
" <PropertyPath>UshortProperty</PropertyPath>\r\n" +
" <PropertyPath>UintProperty</PropertyPath>\r\n" +
" <PropertyPath>UlongProperty</PropertyPath>\r\n" +
" <PropertyPath>GuidProperty</PropertyPath>\r\n" +
" <PropertyPath>DateTimeOffsetProperty</PropertyPath>\r\n" +
" <PropertyPath>StringWithConcurrencyCheckAttributeProperty</PropertyPath>\r\n" +
" </Collection>\r\n" +
" </Annotation>\r\n" +
" </EntitySet>";
string requestUri = string.Format("{0}/odata/$metadata", this.BaseAddress);
HttpResponseMessage response = this.Client.GetAsync(requestUri).Result;
var content = response.Content.ReadAsStringAsync().Result;
Assert.Contains(expectMetadata, content);
var stream = response.Content.ReadAsStreamAsync().Result;
IODataResponseMessage message = new ODataMessageWrapper(stream, response.Content.Headers);
var reader = new ODataMessageReader(message);
var edmModel = reader.ReadMetadataDocument();
Assert.NotNull(edmModel);
var etagCustomers = edmModel.FindDeclaredEntitySet("ETagsCustomers");
Assert.NotNull(etagCustomers);
var annotations = edmModel.FindDeclaredVocabularyAnnotations(etagCustomers);
IEdmVocabularyAnnotation annotation = Assert.Single(annotations);
Assert.NotNull(annotation);
Assert.Same(CoreVocabularyModel.ConcurrencyTerm, annotation.Term);
Assert.Same(etagCustomers, annotation.Target);
IEdmValueAnnotation valueAnnotation = annotation as IEdmValueAnnotation;
Assert.NotNull(valueAnnotation);
Assert.NotNull(valueAnnotation.Value);
IEdmCollectionExpression collection = valueAnnotation.Value as IEdmCollectionExpression;
Assert.NotNull(collection);
Assert.Equal(new[]
{
"Id", "Name", "BoolProperty", "ByteProperty", "CharProperty", "DecimalProperty",
"DoubleProperty", "ShortProperty", "LongProperty", "SbyteProperty",
"FloatProperty", "UshortProperty", "UintProperty", "UlongProperty",
"GuidProperty", "DateTimeOffsetProperty",
"StringWithConcurrencyCheckAttributeProperty"
},
collection.Elements.Select(e => ((IEdmPathExpression) e).Path.Single()));
}
public async Task VerifyMetaDataIsGeneratedCorrectly()
{
var response = await Client.GetAsync(BaseAddress + "/$metadata");
var stream = await response.Content.ReadAsStreamAsync();
IODataResponseMessage message = new ODataMessageWrapper(stream, response.Content.Headers);
var reader = new ODataMessageReader(message);
var edmModel = reader.ReadMetadataDocument();
Assert.Equal(4, edmModel.GetEdmVersion().Major);
var container = edmModel.EntityContainer;
Assert.Equal("Container", container.Name);
Assert.Equal(3, container.Elements.Count());
var address = edmModel.SchemaElements.OfType<IEdmComplexType>().First();
Assert.Equal("Address", address.Name);
Assert.Equal(5, address.Properties().Count());
var product = edmModel.SchemaElements.Where(e => e.Name == "Product").First() as IEdmEntityType;
Assert.Equal(1, product.Key().Count());
Assert.Equal("ID", product.Key().First().Name);
Assert.Equal(5, product.Properties().Count());
var supplier = edmModel.SchemaElements.Where(e => e.Name == "Supplier").First() as IEdmEntityType;
Assert.Equal(1, supplier.Key().Count());
Assert.Equal("ID", supplier.Key().First().Name);
Assert.Equal(6, supplier.Properties().Count());
var addressesProperty = supplier.Properties().First(p => p.Name == "Addresses").Type.AsCollection();
Assert.Equal(typeof(Address).FullName, addressesProperty.CollectionDefinition().ElementType.FullName());
// [ODATA-CSDL]
// In 6.2.1
// a) If not value is specified for a property whose Type attribute does not specify a collection,
// the Nuallable attribute defaults to true
// b) A property whose Type attribute specifies a collection MUST NOT specify a value for the
// Nullable attribute as the collection always exists, it may just be empty.
Assert.Equal(true, addressesProperty.IsNullable);
var tagsProperty = supplier.Properties().First(p => p.Name == "Tags").Type.AsCollection();
Assert.Equal("Edm.String", tagsProperty.CollectionDefinition().ElementType.FullName());
Assert.Equal(true, tagsProperty.IsNullable);
}
public async Task ModelBuilderTest(string routing)
{
// Arrange
string requestUri = string.Format("{0}/{1}/$metadata", this.BaseAddress, routing);
var typeOfEmployee = typeof(Employee);
// Act
HttpResponseMessage response = await Client.GetAsync(requestUri);
var stream = response.Content.ReadAsStreamAsync().Result;
IODataResponseMessage message = new ODataMessageWrapper(stream, response.Content.Headers);
var reader = new ODataMessageReader(message);
var edmModel = reader.ReadMetadataDocument();
// Assert
#region functions
// Function GetCount
var iEdmOperationsOfGetCount = edmModel.FindDeclaredOperations("Default.GetCount");
Assert.Equal(3, iEdmOperationsOfGetCount.Count());
// (Collection(Employee)).GetCount(String Name)
var getCount = iEdmOperationsOfGetCount.Where(f => f.Parameters.Count() == 2);
Assert.Equal(1, getCount.Count());
// (Collection(Manager)).GetCount()
foreach (var t in iEdmOperationsOfGetCount)
{
var t1 = t.Parameters.First().Type.Definition.ToString();
var t2 = t.Parameters.First().Type;
}
getCount = iEdmOperationsOfGetCount.Where(f => f.Parameters.Count() == 1
&& f.Parameters.First().Type.Definition.ToString()
.Equals(string.Format("Collection([{0} Nullable=True])", Manager)));
Assert.Equal(1, getCount.Count());
// (Collection(Employee)).GetCount()
getCount = iEdmOperationsOfGetCount.Where(f => f.Parameters.Count() == 1
&& f.Parameters.First().Type.Definition.ToString()
.Equals(string.Format("Collection([{0} Nullable=True])", Employee)));
Assert.Equal(1, getCount.Count());
// Function GetEmailsCount()
var iEdmOperationsOfGetEmailsCount = edmModel.FindDeclaredOperations("Default.GetEmailsCount");
Assert.Equal(2, iEdmOperationsOfGetEmailsCount.Count());
// Empllyee.GetEmailCount()
var getEmailsCount = iEdmOperationsOfGetEmailsCount.Where(f => f.Parameters.Count() == 1
&& f.Parameters.First().Type.Definition.ToString().Equals(Employee));
Assert.Equal(1, getEmailsCount.Count());
// Manager.GetEmailCount()
getEmailsCount = iEdmOperationsOfGetEmailsCount.Where(f => f.Parameters.Count() == 1
&& f.Parameters.First().Type.Definition.ToString().Equals(Manager));
Assert.Equal(1, getEmailsCount.Count());
// primitive & collection of primitive
AssertPrimitiveOperation(edmModel, "Default.PrimitiveFunction");
// Enum & collection of Enum
AssertEnumOperation(edmModel, "Default.EnumFunction");
// Complex & collection of Complex
AssertComplexOperation(edmModel, "Default.ComplexFunction");
// Entity & collection of Entity
AssertEntityOperation(edmModel, "Default.EntityFunction");
#endregion
#region actions
// Action IncreaseSalary
var iEdmOperationOfIncreaseSalary = edmModel.FindDeclaredOperations("Default.IncreaseSalary");
Assert.Equal(4, iEdmOperationOfIncreaseSalary.Count());
// (Collection(Employee)).IncreaseSalary(String Name)
var increaseSalary = iEdmOperationOfIncreaseSalary.Where(a => a.Parameters.Count() == 2
&& a.Parameters.First().Type.Definition.ToString().Equals(CollectionOfEmployee));
Assert.NotNull(increaseSalary);
// (Collection(Manager)).IncreaseSalary()
increaseSalary = iEdmOperationOfIncreaseSalary.Where(a => a.Parameters.Count() == 1
&& a.Parameters.First().Type.Definition.ToString().Equals(CollectionOfManager));
Assert.NotNull(increaseSalary);
// Employee.IncreaseSalary()
increaseSalary = iEdmOperationOfIncreaseSalary.Where(a => a.Parameters.Count() == 1
&& a.Parameters.First().Type.Definition.ToString().Equals(Employee));
Assert.NotNull(increaseSalary);
// Manager.IncreaseSalary()
increaseSalary = iEdmOperationOfIncreaseSalary.Where(a => a.Parameters.Count() == 1
&& a.Parameters.First().Type.Definition.ToString().Equals(Manager));
Assert.NotNull(increaseSalary);
// primitive & collection of primitive
AssertPrimitiveOperation(edmModel, "Default.PrimitiveAction");
// Enum & collection of Enum
AssertEnumOperation(edmModel, "Default.EnumAction");
// Complex & collection of Complex
AssertComplexOperation(edmModel, "Default.ComplexAction");
// Entity & collection of Entity
AssertEntityOperation(edmModel, "Default.EntityAction");
#endregion
// ActionImport: ResetDataSource
Assert.Equal(1, edmModel.EntityContainer.OperationImports().Count());
}
