public void CanCreateEntityWithPrimitiveAndEnumKey()
{
// Arrange
ODataModelBuilder builder = new ODataModelBuilder();
var enumEntityType = builder.EntityType <EnumModel>();
enumEntityType.HasKey(c => new { c.Simple, c.Id });
// Act
IEdmModel model = builder.GetServiceModel();
// Assert
IEdmEntityType entityType = model.SchemaElements.OfType <IEdmEntityType>()
.FirstOrDefault(c => c.Name == "EnumModel");
Assert.NotNull(entityType);
Assert.Equal(2, entityType.Properties().Count());
Assert.Equal(2, entityType.DeclaredKey.Count());
IEdmStructuralProperty enumKey = entityType.DeclaredKey.First(k => k.Name == "Simple");
Assert.Equal(EdmTypeKind.Enum, enumKey.Type.TypeKind());
Assert.Equal("Microsoft.TestCommon.Types.SimpleEnum", enumKey.Type.Definition.FullTypeName());
IEdmStructuralProperty primitiveKey = entityType.DeclaredKey.First(k => k.Name == "Id");
Assert.Equal(EdmTypeKind.Primitive, primitiveKey.Type.TypeKind());
Assert.Equal("Edm.Int32", primitiveKey.Type.Definition.FullTypeName());
}
public void CreateTimeOfDayPrimitiveProperty_FromTimeSpan()
{
// Arrange
ODataModelBuilder builder = new ODataModelBuilder();
EntityTypeConfiguration <File> file = builder.EntityType <File>();
file.Property(f => f.CreatedTime).AsTimeOfDay();
file.Property(f => f.EndTime).AsTimeOfDay();
// Act
IEdmModel model = builder.GetServiceModel();
// Assert
IEdmEntityType fileType = Assert.Single(model.SchemaElements.OfType <IEdmEntityType>());
IEdmProperty createProperty = Assert.Single(fileType.DeclaredProperties.Where(p => p.Name == "CreatedTime"));
Assert.NotNull(createProperty);
Assert.False(createProperty.Type.IsNullable);
Assert.Equal("Edm.TimeOfDay", createProperty.Type.FullName());
IEdmProperty endProperty = Assert.Single(fileType.DeclaredProperties.Where(p => p.Name == "EndTime"));
Assert.NotNull(endProperty);
Assert.True(endProperty.Type.IsNullable);
Assert.Equal("Edm.TimeOfDay", endProperty.Type.FullName());
}
public void CreateEntityTypeWithRelationship()
{
var builder = new ODataModelBuilder().Add_Customer_EntityType().Add_Order_EntityType().Add_OrderCustomer_Relationship();
var model = builder.GetServiceModel();
var orderType = model.SchemaElements.OfType <IEdmEntityType>().SingleOrDefault(t => t.Name == "Order");
Assert.NotNull(orderType);
Assert.Equal("Order", orderType.Name);
Assert.Equal(typeof(Order).Namespace, orderType.Namespace);
Assert.Equal("OrderId", orderType.DeclaredKey.Single().Name);
Assert.Equal(5, orderType.DeclaredProperties.Count());
Assert.Equal(1, orderType.NavigationProperties().Count());
var deliveryDateProperty = orderType.DeclaredProperties.Single(dp => dp.Name == "DeliveryDate");
Assert.NotNull(deliveryDateProperty);
Assert.True(deliveryDateProperty.Type.IsNullable);
Assert.Equal("Customer", orderType.NavigationProperties().First().Name);
Assert.Equal("Customer", orderType.NavigationProperties().First().ToEntityType().Name);
var customerType = model.SchemaElements.OfType <IEdmEntityType>().SingleOrDefault(t => t.Name == "Customer");
Assert.NotNull(customerType);
Assert.Equal("Customer", customerType.Name);
Assert.Equal(typeof(Customer).Namespace, customerType.Namespace);
Assert.Equal("CustomerId", customerType.DeclaredKey.Single().Name);
Assert.Equal(5, customerType.DeclaredProperties.Count());
}
public void CanCreateEntityWithCollectionProperties()
{
var builder = new ODataModelBuilder();
var customer = builder.EntityType <Customer>();
customer.HasKey(c => c.CustomerId);
customer.CollectionProperty(c => c.Aliases);
customer.CollectionProperty(c => c.Addresses);
var aliasesProperty = customer.Properties.OfType <CollectionPropertyConfiguration>().SingleOrDefault(p => p.Name == "Aliases");
var addressesProperty = customer.Properties.OfType <CollectionPropertyConfiguration>().SingleOrDefault(p => p.Name == "Addresses");
Assert.Equal(3, customer.Properties.Count());
Assert.Equal(2, customer.Properties.OfType <CollectionPropertyConfiguration>().Count());
Assert.NotNull(aliasesProperty);
Assert.Equal(typeof(string), aliasesProperty.ElementType);
Assert.NotNull(addressesProperty);
Assert.Equal(typeof(Address), addressesProperty.ElementType);
Assert.Equal(2, builder.StructuralTypes.Count());
var addressType = builder.StructuralTypes.Skip(1).FirstOrDefault();
Assert.NotNull(addressType);
Assert.Equal(EdmTypeKind.Complex, addressType.Kind);
Assert.Equal(typeof(Address).FullName, addressType.FullName);
var model = builder.GetServiceModel();
var edmCustomerType = model.FindType(typeof(Customer).FullName) as IEdmEntityType;
var edmAddressType = model.FindType(typeof(Address).FullName) as IEdmComplexType;
}
public void CreateDatePrimitiveProperty_FromDateTime()
{
// Arrange
ODataModelBuilder builder = new ODataModelBuilder();
EntityTypeConfiguration <File> file = builder.EntityType <File>();
file.Property(f => f.Birthday).AsDate();
file.Property(f => f.PublishDay).AsDate();
// Act
IEdmModel model = builder.GetServiceModel();
// Assert
IEdmEntityType fileType = Assert.Single(model.SchemaElements.OfType <IEdmEntityType>());
IEdmProperty birthdayProperty = Assert.Single(fileType.DeclaredProperties.Where(p => p.Name == "Birthday"));
Assert.NotNull(birthdayProperty);
Assert.False(birthdayProperty.Type.IsNullable);
Assert.Equal("Edm.Date", birthdayProperty.Type.FullName());
IEdmProperty publishDayProperty = Assert.Single(fileType.DeclaredProperties.Where(p => p.Name == "PublishDay"));
Assert.NotNull(publishDayProperty);
Assert.True(publishDayProperty.Type.IsNullable);
Assert.Equal("Edm.Date", publishDayProperty.Type.FullName());
}
public void CreateComplexTypeProperty()
{
var builder = new ODataModelBuilder().Add_Customer_EntityType().Add_Address_ComplexType();
builder.EntityType <Customer>().ComplexProperty(c => c.Address);
var model = builder.GetServiceModel();
var customerType = model.SchemaElements.OfType <IEdmEntityType>().Single();
var addressProperty = customerType.FindProperty("Address");
Assert.NotNull(addressProperty);
}
public void CanEmitModelWithTwoEntitiesAndARelationshipWithNoBinding()
{
var builder = new ODataModelBuilder()
.Add_Order_EntityType()
.Add_Customer_EntityType()
.Add_CustomerOrders_Relationship()
.Add_Customers_EntitySet()
.Add_Orders_EntitySet();
var model = builder.GetServiceModel();
var csdl = GetCSDL(model);
}
public void CanEmitModelWithSingleton()
{
// Arrange
var builder = new ODataModelBuilder()
.Add_Company_Singleton();
// Act
var model = builder.GetServiceModel();
// Assert
var csdl = GetCSDL(model);
}
public void CanEmitModelWithTwoEntitiesAndATwoWayRelationship()
{
var builder = new ODataModelBuilder()
.Add_Order_EntityType()
.Add_Customer_EntityType()
.Add_Customers_EntitySet()
.Add_Orders_EntitySet()
.Add_CustomerOrders_Binding() // creates nav prop too
.Add_OrderCustomer_Binding(); // creates nav prop too
var model = builder.GetServiceModel();
var csdl = GetCSDL(model);
}
public void CreateEntityType()
{
var builder = new ODataModelBuilder().Add_Customer_EntityType();
var model = builder.GetServiceModel();
var customerType = model.SchemaElements.OfType <IEdmEntityType>().SingleOrDefault(t => t.Name == "Customer");
Assert.NotNull(customerType);
Assert.Equal("Customer", customerType.Name);
Assert.Equal(typeof(Customer).Namespace, customerType.Namespace);
Assert.Equal("CustomerId", customerType.DeclaredKey.Single().Name);
Assert.Equal(5, customerType.DeclaredProperties.Count());
}
public void ODataModelBuilder_Throws_AddCollectionOfEnumPropertyWithoutEnumType()
{
// Arrange
var builder = new ODataModelBuilder();
var complexTypeConfiguration = builder.ComplexType <ComplexTypeWithEnumTypePropertyTestModel>();
complexTypeConfiguration.CollectionProperty(c => c.Colors);
// Act & Assert
Assert.Throws <InvalidOperationException>(
() => builder.GetServiceModel(),
"The enum type 'Color' does not exist.");
}
public void ValueOfEnumMemberCannotBeConvertedToLongShouldThrowException()
{
// Arrange
var builder = new ODataModelBuilder();
var color = builder.EnumType <ValueOutOfRangeEnum>();
color.Member(ValueOutOfRangeEnum.Member);
// Act & Assert
Assert.ThrowsArgument(
() => builder.GetServiceModel(),
"value",
"The value of enum member 'Member' cannot be converted to a long type.");
}
public void CreateStreamPrimitiveProperty()
{
ODataModelBuilder builder = new ODataModelBuilder();
var file = builder.EntityType <File>();
var data = file.Property(f => f.StreamData);
var model = builder.GetServiceModel();
var fileType = model.SchemaElements.OfType <IEdmEntityType>().Single();
var streamProperty = fileType.DeclaredProperties.SingleOrDefault(p => p.Name == "StreamData");
Assert.Equal(PropertyKind.Primitive, data.Kind);
Assert.NotNull(streamProperty);
Assert.Equal("Edm.Stream", streamProperty.Type.FullName());
}
public void CreateModelWithEntitySet()
{
var builder = new ODataModelBuilder().Add_Customer_EntityType().Add_Customers_EntitySet();
builder.EntitySet <Customer>("Customers");
var model = builder.GetServiceModel();
var container = model.SchemaElements.OfType <IEdmEntityContainer>().SingleOrDefault();
Assert.NotNull(container);
var customers = container.EntitySets().SingleOrDefault(e => e.Name == "Customers");
Assert.NotNull(customers);
Assert.Equal("Customer", customers.EntityType().Name);
}
public void CanEmitModelWithSingletonHasEntitysetBinding()
{
// Arrange
var builder = new ODataModelBuilder()
.Add_Company_EntityType()
.Add_Employee_EntityType()
.Add_CompanyEmployees_Relationship()
.Add_EmployeeComplany_Relationship()
.Add_MicrosoftEmployees_Binding();
// Act
var model = builder.GetServiceModel();
// Assert
var csdl = GetCSDL(model);
}
public void CanCreateEntityWithCompoundKey()
{
var builder = new ODataModelBuilder();
var customer = builder.EntityType <Customer>();
customer.HasKey(c => new { c.CustomerId, c.Name });
customer.Property(c => c.SharePrice);
customer.Property(c => c.ShareSymbol);
customer.Property(c => c.Website);
var model = builder.GetServiceModel();
var customerType = model.FindType(typeof(Customer).FullName) as IEdmEntityType;
Assert.Equal(5, customerType.Properties().Count());
Assert.Equal(2, customerType.DeclaredKey.Count());
Assert.NotNull(customerType.DeclaredKey.SingleOrDefault(k => k.Name == "CustomerId"));
Assert.NotNull(customerType.DeclaredKey.SingleOrDefault(k => k.Name == "Name"));
}
public void CreateTimeOfDayPrimitiveProperty()
{
// Arrange
ODataModelBuilder builder = new ODataModelBuilder();
EntityTypeConfiguration <File> file = builder.EntityType <File>();
PrimitivePropertyConfiguration timeOfDay = file.Property(f => f.TimeOfDayProperty);
// Act
IEdmModel model = builder.GetServiceModel();
// Assert
Assert.Equal(PropertyKind.Primitive, timeOfDay.Kind);
IEdmEntityType fileType = Assert.Single(model.SchemaElements.OfType <IEdmEntityType>());
IEdmProperty property = Assert.Single(fileType.DeclaredProperties.Where(p => p.Name == "TimeOfDayProperty"));
Assert.NotNull(property);
Assert.Equal("Edm.TimeOfDay", property.Type.FullName());
}
public void CreateComplexTypePropertyInComplexType()
{
var builder = new ODataModelBuilder()
.Add_Address_ComplexType();
var address = builder.ComplexType <Address>();
address.ComplexProperty(a => a.ZipCode);
var model = builder.GetServiceModel();
var addressType = model.SchemaElements.OfType <IEdmComplexType>().SingleOrDefault(se => se.Name == "Address");
var zipCodeType = model.SchemaElements.OfType <IEdmComplexType>().SingleOrDefault(se => se.Name == "ZipCode");
Assert.NotNull(addressType);
Assert.NotNull(zipCodeType);
var zipCodeProperty = addressType.FindProperty("ZipCode");
Assert.NotNull(zipCodeProperty);
Assert.Equal(zipCodeType.FullName(), zipCodeProperty.Type.AsComplex().ComplexDefinition().FullName());
}
public void CanCreateEntityWithCompoundKey_ForDateAndTimeOfDay()
{
// Arrange
var builder = new ODataModelBuilder();
var entity = builder.EntityType <EntityTypeWithDateAndTimeOfDay>();
entity.HasKey(e => new { e.Date, e.TimeOfDay });
// Act
var model = builder.GetServiceModel();
// Assert
var entityType =
model.SchemaElements.OfType <IEdmEntityType>().Single(e => e.Name == "EntityTypeWithDateAndTimeOfDay");
Assert.Equal(2, entityType.Properties().Count());
Assert.Equal(2, entityType.DeclaredKey.Count());
Assert.NotNull(entityType.DeclaredKey.SingleOrDefault(k => k.Name == "Date"));
Assert.NotNull(entityType.DeclaredKey.SingleOrDefault(k => k.Name == "TimeOfDay"));
}
public void CreateModelWithTwoEntitySetsAndABinding()
{
var builder = new ODataModelBuilder()
.Add_Customer_EntityType()
.Add_Order_EntityType()
.Add_CustomerOrders_Relationship()
.Add_CustomerOrders_Binding();
var model = builder.GetServiceModel();
var container = model.SchemaElements.OfType <IEdmEntityContainer>().SingleOrDefault();
Assert.NotNull(container);
var customers = container.EntitySets().SingleOrDefault(e => e.Name == "Customers");
Assert.NotNull(customers);
var orders = container.EntitySets().SingleOrDefault(e => e.Name == "Orders");
Assert.NotNull(orders);
var customerOrders = customers.NavigationPropertyBindings.FirstOrDefault(nt => nt.NavigationProperty.Name == "Orders");
Assert.NotNull(customerOrders);
Assert.Equal("Orders", customerOrders.Target.Name);
}
public void CreateComplexTypeByConvention()
{
var builder = new ODataModelBuilder().Add_Address_ComplexType();
var model = builder.GetServiceModel();
var addressType = model.SchemaElements.OfType <IEdmComplexType>().Single();
Assert.Equal("Address", addressType.Name);
Assert.Equal(4, addressType.DeclaredProperties.Count());
var houseNumberProperty = addressType.DeclaredProperties.SingleOrDefault(p => p.Name == "HouseNumber");
var streetProperty = addressType.DeclaredProperties.SingleOrDefault(p => p.Name == "Street");
var cityProperty = addressType.DeclaredProperties.SingleOrDefault(p => p.Name == "City");
var stateProperty = addressType.DeclaredProperties.SingleOrDefault(p => p.Name == "State");
var zipCodeProperty = addressType.DeclaredProperties.SingleOrDefault(p => p.Name == "ZipCode");
Assert.NotNull(houseNumberProperty);
Assert.NotNull(streetProperty);
Assert.NotNull(cityProperty);
Assert.NotNull(stateProperty);
Assert.Null(zipCodeProperty);
Assert.Equal("Edm.Int32", houseNumberProperty.Type.FullName());
Assert.Equal("Edm.String", streetProperty.Type.FullName());
}
public void CreateModelUsingProgrammableApi()
{
var builder = new ODataModelBuilder();
var customerConfig = builder.AddEntityType(typeof(Customer));
customerConfig.HasKey(typeof(Customer).GetProperty("CustomerId"));
customerConfig.AddProperty(typeof(Customer).GetProperty("Name"));
var ordersPropertyConfig = customerConfig.AddNavigationProperty(typeof(Customer).GetProperty("Orders"), EdmMultiplicity.Many);
var orderConfig = builder.AddEntityType(typeof(Order));
orderConfig.HasKey(typeof(Order).GetProperty("OrderId"));
orderConfig.AddProperty(typeof(Order).GetProperty("Cost"));
var customersSetConfig = builder.AddEntitySet("Customers", customerConfig);
var ordersSetConfig = builder.AddEntitySet("Orders", orderConfig);
customersSetConfig.AddBinding(ordersPropertyConfig, ordersSetConfig);
var meConfig = builder.AddSingleton("Me", customerConfig);
var model = builder.GetServiceModel();
var customerType = model.SchemaElements.OfType <IEdmEntityType>().Single(e => e.Name == "Customer");
Assert.NotNull(customerType);
Assert.Equal(typeof(Customer).Namespace, customerType.Namespace);
Assert.Equal(3, customerType.DeclaredProperties.Count());
var key = customerType.DeclaredKey.SingleOrDefault();
Assert.NotNull(key);
Assert.Equal("CustomerId", key.Name);
Assert.True(key.Type.IsInt32());
Assert.False(key.Type.IsNullable);
var nameProperty = customerType.DeclaredProperties.SingleOrDefault(dp => dp.Name == "Name");
Assert.NotNull(nameProperty);
Assert.True(nameProperty.Type.IsString());
Assert.True(nameProperty.Type.IsNullable);
Assert.Equal(1, customerType.NavigationProperties().Count());
var ordersProperty = customerType.NavigationProperties().Single();
Assert.Equal("Orders", ordersProperty.Name);
Assert.Equal(EdmTypeKind.Collection, ordersProperty.Type.Definition.TypeKind);
Assert.Equal(typeof(Order).FullName, (ordersProperty.Type.Definition as IEdmCollectionType).ElementType.FullName());
var entityContainer = model.EntityContainer;
Assert.NotNull(entityContainer);
var customers = entityContainer.FindEntitySet("Customers");
Assert.NotNull(customers);
Assert.Equal(typeof(Customer).FullName, customers.EntityType().FullName());
var orders = entityContainer.FindEntitySet("Orders");
Assert.NotNull(orders);
Assert.Equal(typeof(Order).FullName, orders.EntityType().FullName());
var me = entityContainer.FindSingleton("Me");
Assert.NotNull(me);
Assert.Equal(typeof(Customer).FullName, me.EntityType().FullName());
}
public void CanEmitModelWithSingleEntity()
{
var builder = new ODataModelBuilder().Add_Customer_EntityType();
var model = builder.GetServiceModel();
var csdl = GetCSDL(model);
}
public void CanEmitModelWithSingleComplexType()
{
var builder = new ODataModelBuilder().Add_Address_ComplexType();
var model = builder.GetServiceModel();
var csdl = GetCSDL(model);
}
