public void DerivesFrom_Throws_IfDerivedTypeHasKeys()
{
var builder = new ODataModelBuilder();
Assert.Throws <InvalidOperationException>(
() => builder
.Entity <Motorcycle>()
.HasKey(m => m.Model)
.DerivesFrom <Vehicle>(),
"Cannot define keys on type 'System.Web.Http.OData.Builder.TestModels.Motorcycle' deriving from 'System.Web.Http.OData.Builder.TestModels.Vehicle'. Only the root type in the entity inheritance hierarchy can contain keys.");
}
public void DerivesFrom_Throws_WhenSettingTheBaseType_IfDuplicatePropertyInDerivedType()
{
var builder = new ODataModelBuilder();
builder
.Entity <Vehicle>()
.Property(v => v.Model);
builder
.Entity <SportBike>()
.DerivesFrom <Motorcycle>()
.Property(c => c.Model);
Assert.ThrowsArgument(
() => builder
.Entity <Motorcycle>()
.DerivesFrom <Vehicle>(),
"propertyInfo",
"Cannot define property 'Model' in the base entity type 'System.Web.Http.OData.Builder.TestModels.Motorcycle' as the derived type 'System.Web.Http.OData.Builder.TestModels.SportBike' already defines it.");
}
public void CannotDeriveFromItself()
{
var builder = new ODataModelBuilder();
Assert.ThrowsArgument(
() => builder
.Entity <Vehicle>()
.DerivesFrom <Vehicle>(),
"baseType",
"'System.Web.Http.OData.Builder.TestModels.Vehicle' does not inherit from 'System.Web.Http.OData.Builder.TestModels.Vehicle'.");
}
public void DerivesFrom_Throws_IfDerivedTypeDoesNotDeriveFromBaseType()
{
var builder = new ODataModelBuilder();
Assert.ThrowsArgument(
() => builder
.Entity <string>()
.DerivesFrom <Vehicle>(),
"baseType",
"'System.String' does not inherit from 'System.Web.Http.OData.Builder.TestModels.Vehicle'.");
}
public void SetNonPrimitiveProperty_ThrowsException()
{
// Arrange
ODataModelBuilder builder = new ODataModelBuilder();
// Act & Assert
Assert.Throws <InvalidOperationException>(
() => builder.Entity <ForeignEntity>().HasRequired(c => c.Principal,
(c, r) => c.InvalidForeignKey == r.InvalidPrincipalKey),
String.Format(SRResources.ReferentialConstraintPropertyTypeNotValid, "System.Web.Http.OData.MockType"));
}
public void CreateComplexTypeProperty()
{
var builder = new ODataModelBuilder().Add_Customer_EntityType().Add_Address_ComplexType();
builder.Entity <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 ReturnsCollection_ThrowsInvalidOperationException_IfReturnTypeIsEntity()
{
// Arrange
ODataModelBuilder builder = new ODataModelBuilder();
builder.Entity <Movie>();
var action = builder.Action("action");
// Act & Assert
Assert.Throws <InvalidOperationException>(() => action.ReturnsCollection <Movie>(),
"The EDM type 'System.Web.Http.OData.Builder.Movie' is already declared as an entity type. Use the " +
"method 'ReturnsCollectionFromEntitySet' if the return type is an entity collection.");
}
public void CanCreateTransientAction()
{
ODataModelBuilder builder = new ODataModelBuilder();
EntityTypeConfiguration <Customer> customer = builder.Entity <Customer>();
customer.TransientAction("Reward");
ProcedureConfiguration action = builder.Procedures.SingleOrDefault();
Assert.NotNull(action);
Assert.True(action.IsBindable);
Assert.False(action.IsAlwaysBindable);
}
public void GetEdmModel_Works_WithMultiForeignKeys()
{
// Arrange
ODataModelBuilder builder = new ODataModelBuilder();
EntityTypeConfiguration <MultiUser> userType = builder.Entity <MultiUser>();
userType.HasKey(u => new { u.UserId1, u.UserId2 })
.HasMany(u => u.Roles);
EntityTypeConfiguration <MultiRole> roleType = builder.Entity <MultiRole>();
roleType.HasKey(r => r.RoleId)
.HasOptional(r => r.User, (r, u) => r.UserKey1 == u.UserId1 && r.UserKey2 == u.UserId2)
.CascadeOnDelete();
// Act
IEdmModel model = builder.GetEdmModel();
// Assert
Assert.NotNull(model);
IEdmEntityType roleEntityType = model.AssertHasEntityType(typeof(MultiRole));
IEdmNavigationProperty usersNav = roleEntityType.AssertHasNavigationProperty(model, "User",
typeof(MultiUser), true, EdmMultiplicity.ZeroOrOne);
Assert.Equal(EdmOnDeleteAction.Cascade, usersNav.OnDelete);
Assert.Equal(2, usersNav.DependentProperties.Count());
Assert.Equal("UserKey1", usersNav.DependentProperties.First().Name);
Assert.Equal("UserKey2", usersNav.DependentProperties.Last().Name);
IEdmProperty edmProperty = Assert.Single(roleEntityType.Properties().Where(c => c.Name == "UserKey1"));
Assert.False(edmProperty.Type.IsNullable);
edmProperty = Assert.Single(roleEntityType.Properties().Where(c => c.Name == "UserKey2"));
Assert.False(edmProperty.Type.IsNullable);
}
public void CanCreateAbstractEntityType()
{
var builder = new ODataModelBuilder();
builder
.Entity <Vehicle>()
.Abstract();
var model = builder.GetEdmModel();
var edmCustomerType = model.FindType(typeof(Vehicle).FullName) as IEdmEntityType;
Assert.True(edmCustomerType != null);
Assert.True(edmCustomerType.IsAbstract);
}
public void GetEdmModel_PropertyWithConcurrency_IsConcurrencyToken()
{
// Arrange
var builder = new ODataModelBuilder();
builder.Entity <Customer>().Property(c => c.Name).IsConcurrencyToken();
builder.Entity <Customer>().Property(c => c.Id);
// Act
var model = builder.GetEdmModel();
// Assert
IEdmEntityType type = model.AssertHasEntityType(typeof(Customer));
IEdmStructuralProperty nameProperty =
type.AssertHasPrimitiveProperty(model, "Name", EdmPrimitiveTypeKind.String, isNullable: true);
Assert.Equal(EdmConcurrencyMode.Fixed, nameProperty.ConcurrencyMode);
IEdmStructuralProperty idProperty =
type.AssertHasPrimitiveProperty(model, "Id", EdmPrimitiveTypeKind.Int32, isNullable: false);
Assert.Equal(EdmConcurrencyMode.None, idProperty.ConcurrencyMode);
}
public void CreateStreamPrimitiveProperty()
{
ODataModelBuilder builder = new ODataModelBuilder();
var file = builder.Entity <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 CanCreateActionThatBindsToEntityCollection()
{
// Arrange
// Act
ODataModelBuilder builder = new ODataModelBuilder();
EntityTypeConfiguration <Customer> customer = builder.Entity <Customer>();
ActionConfiguration sendEmail = customer.Collection.Action("SendEmail");
// Assert
Assert.True(sendEmail.IsBindable);
Assert.NotNull(sendEmail.Parameters);
Assert.Equal(1, sendEmail.Parameters.Count());
Assert.Equal(BindingParameterConfiguration.DefaultBindingParameterName, sendEmail.Parameters.Single().Name);
Assert.Equal(string.Format("Collection({0})", typeof(Customer).FullName), sendEmail.Parameters.Single().TypeConfiguration.FullName);
}
public void ComplexCollections_Are_NotNullable_ByDefault()
{
var builder = new ODataModelBuilder();
var property =
builder
.Entity <Customer>()
.CollectionProperty(c => c.Addresses);
var model = builder.GetEdmModel();
Assert.False(property.OptionalProperty);
var edmCustomer = model.AssertHasEntityType(typeof(Customer));
Assert.False(edmCustomer.FindProperty("Addresses").Type.IsNullable);
}
public void NonbindingParameterConfigurationThrowsWhenParameterTypeIsEntity()
{
// Arrange
ODataModelBuilder builder = new ODataModelBuilder();
builder.Entity <Customer>();
// Act & Assert
ArgumentException exception = Assert.Throws <ArgumentException>(() =>
{
NonbindingParameterConfiguration configuration = new NonbindingParameterConfiguration("name", builder.GetTypeConfigurationOrNull(typeof(Customer)));
});
Assert.True(exception.Message.Contains(string.Format("'{0}'", typeof(Customer).FullName)));
Assert.Equal("parameterType", exception.ParamName);
}
public void CanCreateEntityWithCompoundKey()
{
var builder = new ODataModelBuilder();
var customer = builder.Entity <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 HasRequired_CanSetMultipleForeignKeyProperties_ForReferencialConstraint()
{
// Arrange
ODataModelBuilder builder = new ODataModelBuilder();
// Act
NavigationPropertyConfiguration navigationProperty =
builder.Entity <MultiRole>()
.HasRequired(r => r.User, (r, u) => r.UserKey1 == u.UserId1 && r.UserKey2 == u.UserId2);
// Assert
Assert.Equal(2, navigationProperty.DependentProperties.Count());
Assert.Same(typeof(MultiRole).GetProperty("UserKey1"), navigationProperty.DependentProperties.First());
Assert.Same(typeof(MultiRole).GetProperty("UserKey2"), navigationProperty.DependentProperties.Last());
Assert.Equal(2, navigationProperty.PrincipalProperties.Count());
Assert.Same(typeof(MultiUser).GetProperty("UserId1"), navigationProperty.PrincipalProperties.First());
Assert.Same(typeof(MultiUser).GetProperty("UserId2"), navigationProperty.PrincipalProperties.Last());
}
public void GetEdmModel_PropertyWithDatabaseAttribute_SetStoreGeneratedPatternOnEntityType()
{
// Arrange
ODataModelBuilder builder = new ODataModelBuilder();
builder.Entity <Customer>().Property(c => c.Name).HasStoreGeneratedPattern(DatabaseGeneratedOption.Computed);
// Act
IEdmModel model = builder.GetEdmModel();
// Assert
IEdmEntityType type = model.AssertHasEntityType(typeof(Customer));
IEdmStructuralProperty property = type.AssertHasPrimitiveProperty(model, "Name", EdmPrimitiveTypeKind.String, isNullable: true);
var idAnnotation = model.GetAnnotationValue <EdmStringConstant>(
property,
StoreGeneratedPatternAnnotation.AnnotationsNamespace,
StoreGeneratedPatternAnnotation.AnnotationName);
Assert.Equal(DatabaseGeneratedOption.Computed.ToString(), idAnnotation.Value);
}
public NavigationPropertyBindingConfiguration HasManyBinding <TTargetType, TDerivedEntityType>(
Expression <Func <TDerivedEntityType, IEnumerable <TTargetType> > > navigationExpression, string entitySetName)
where TTargetType : class
where TDerivedEntityType : class, TEntityType
{
if (navigationExpression == null)
{
throw Error.ArgumentNull("navigationExpression");
}
EntityTypeConfiguration <TDerivedEntityType> derivedEntityType =
_modelBuilder.Entity <TDerivedEntityType>().DerivesFrom <TEntityType>();
return(_configuration.AddBinding(derivedEntityType.HasMany(navigationExpression), _modelBuilder.EntitySet <TTargetType>(entitySetName)._configuration));
}
public void CanAddPrimitiveProperty_ForDependentEntityType()
{
// Arrange
ODataModelBuilder builder = new ODataModelBuilder();
// Act
builder.Entity <Role>().HasRequired(r => r.User, (r, u) => r.UserForeignKey == u.UserId);
// Assert
EntityTypeConfiguration dependentEntityType =
builder.StructuralTypes.OfType <EntityTypeConfiguration>().FirstOrDefault(e => e.Name == "Role");
Assert.NotNull(dependentEntityType);
PrimitivePropertyConfiguration primitiveConfig =
Assert.Single(dependentEntityType.Properties.OfType <PrimitivePropertyConfiguration>());
Assert.Equal("UserForeignKey", primitiveConfig.Name);
Assert.Equal("System.Int32", primitiveConfig.RelatedClrType.FullName);
Assert.False(primitiveConfig.OptionalProperty);
}
public void CanDefinePropertyOnDerivedType_NotPresentInBaseEdmType_ButPresentInBaseClrType()
{
var builder = new ODataModelBuilder();
builder
.Entity <Motorcycle>()
.DerivesFrom <Vehicle>()
.Property(m => m.Model);
var model = builder.GetEdmModel();
var edmVehicle = model.AssertHasEntityType(typeof(Vehicle));
Assert.Null(edmVehicle.BaseEntityType());
Assert.Equal(0, edmVehicle.Properties().Count());
var edmMotorcycle = model.AssertHasEntityType(typeof(Motorcycle));
Assert.Equal(edmVehicle, edmMotorcycle.BaseEntityType());
Assert.Equal(1, edmMotorcycle.Properties().Count());
edmMotorcycle.AssertHasPrimitiveProperty(model, "Model", EdmPrimitiveTypeKind.Int32, isNullable: false);
}
public void CanCreateEdmModel_WithTransientBindableAction()
{
// Arrange
ODataModelBuilder builder = new ODataModelBuilder();
EntityTypeConfiguration <Customer> customer = builder.Entity <Customer>();
customer.HasKey(c => c.CustomerId);
customer.Property(c => c.Name);
// Act
ActionConfiguration sendEmail = customer.TransientAction("ActionName");
IEdmModel model = builder.GetEdmModel();
// Assert
IEdmEntityContainer container = model.EntityContainers().SingleOrDefault();
Assert.NotNull(container);
Assert.Equal(1, container.Elements.OfType <IEdmFunctionImport>().Count());
IEdmFunctionImport action = container.Elements.OfType <IEdmFunctionImport>().Single();
Assert.True(action.IsBindable);
Assert.False(model.IsAlwaysBindable(action));
}
