public void Key_column_and_MaxLength_work_together_in_an_IA()
{
using (var entityClassConfiguration = new DynamicTypeDescriptionConfiguration <ColumnKeyAnnotationClass>())
{
entityClassConfiguration.SetPropertyAttributes(c => c.PersonFirstName, new MaxLengthAttribute(64));
var modelBuilder = new DbModelBuilder();
modelBuilder.Entity <ColumnKeyAnnotationClass>();
modelBuilder.Entity <ReferencingClass>();
var databaseMapping = BuildMapping(modelBuilder);
databaseMapping.AssertValid();
databaseMapping.Assert <ColumnKeyAnnotationClass>(x => x.PersonFirstName)
.DbEqual("dsdsd", c => c.Name)
.DbEqual("nvarchar", c => c.TypeName)
.DbEqual(64, f => f.MaxLength)
.DbEqual(true, c => c.IsPrimaryKeyColumn);
Assert.Equal(1, databaseMapping.Model.AssociationTypes.Count());
databaseMapping.Assert <ReferencingClass>().ForeignKeyColumn("Person_PersonFirstName")
.DbEqual("nvarchar", c => c.TypeName)
.DbEqual(64, f => f.MaxLength);
}
}
public void Nothing_to_Required_and_ForeignKey()
{
using (var loginConfiguration = new DynamicTypeDescriptionConfiguration <Login>())
{
using (var profileConfiguration = new DynamicTypeDescriptionConfiguration <Profile>())
{
loginConfiguration.SetPropertyAttributes(l => l.Profile);
profileConfiguration.SetPropertyAttributes(
p => p.User, new RequiredAttribute(),
new ForeignKeyAttribute("ProfileId"));
var modelBuilder = new DbModelBuilder();
modelBuilder.Entity <Login>();
modelBuilder.Entity <Profile>();
var databaseMapping = BuildMapping(modelBuilder);
databaseMapping.AssertValid();
var association = databaseMapping.Model.AssociationTypes.Single();
Assert.Equal("Profile", association.SourceEnd.GetEntityType().Name);
Assert.Equal(RelationshipMultiplicity.ZeroOrOne, association.SourceEnd.RelationshipMultiplicity);
Assert.Equal("Login", association.TargetEnd.GetEntityType().Name);
Assert.Equal(RelationshipMultiplicity.One, association.TargetEnd.RelationshipMultiplicity);
Assert.Equal("Profile", association.Constraint.ToRole.GetEntityType().Name);
}
}
}
private void Can_map_join_table_for_many_to_many_if_names_do_not_match_convention(
Action<DynamicTypeDescriptionConfiguration<SomeRole>,
DynamicTypeDescriptionConfiguration<SomeUser>,
DynamicTypeDescriptionConfiguration<UserRole>,
AdventureWorksModelBuilder> configure)
{
DbDatabaseMapping databaseMapping;
using (var roleConfiguration = new DynamicTypeDescriptionConfiguration<SomeRole>())
{
using (var userConfiguration = new DynamicTypeDescriptionConfiguration<SomeUser>())
{
using (var userRoleConfiguration = new DynamicTypeDescriptionConfiguration<UserRole>())
{
var modelBuilder = new AdventureWorksModelBuilder();
configure(roleConfiguration, userConfiguration, userRoleConfiguration, modelBuilder);
databaseMapping = BuildMapping(modelBuilder);
}
}
}
databaseMapping.Assert<UserRole>().HasColumns("UserId1", "UserId2", "RoleId1", "RoleId2");
databaseMapping.Assert<UserRole>().ColumnCountEquals(4);
databaseMapping.Assert<UserRole>().HasForeignKey(new[] { "UserId1", "UserId2" }, "Users");
databaseMapping.Assert<UserRole>().HasForeignKey(new[] { "RoleId1", "RoleId2" }, "Roles");
}
public void NotMapped_on_unmapped_base_class_property_and_overriden_property_ignores_it()
{
using (var unitConfiguration = new DynamicTypeDescriptionConfiguration <Unit>())
{
using (var baseEntityConfiguration = new DynamicTypeDescriptionConfiguration <BaseEntity>())
{
var modelBuilder = new DbModelBuilder();
baseEntityConfiguration.SetPropertyAttributes(b => b.VirtualBaseClassProperty, new NotMappedAttribute());
unitConfiguration.SetPropertyAttributes(b => b.VirtualBaseClassProperty, new NotMappedAttribute());
modelBuilder.Ignore <AbstractBaseEntity>();
modelBuilder.Ignore <BaseEntity>();
modelBuilder.Entity <Unit>();
var databaseMapping = BuildMapping(modelBuilder);
databaseMapping.AssertValid();
Assert.False(
databaseMapping.Model.EntityTypes.Single().Properties.Any(
p => p.Name == "VirtualBaseClassProperty"));
}
}
}
private void Can_map_join_table_for_many_to_many_if_names_do_not_match_convention(
Action <DynamicTypeDescriptionConfiguration <SomeRole>,
DynamicTypeDescriptionConfiguration <SomeUser>,
DynamicTypeDescriptionConfiguration <UserRole>,
AdventureWorksModelBuilder> configure)
{
DbDatabaseMapping databaseMapping;
using (var roleConfiguration = new DynamicTypeDescriptionConfiguration <SomeRole>())
{
using (var userConfiguration = new DynamicTypeDescriptionConfiguration <SomeUser>())
{
using (var userRoleConfiguration = new DynamicTypeDescriptionConfiguration <UserRole>())
{
var modelBuilder = new AdventureWorksModelBuilder();
configure(roleConfiguration, userConfiguration, userRoleConfiguration, modelBuilder);
databaseMapping = BuildMapping(modelBuilder);
}
}
}
databaseMapping.Assert <UserRole>().HasColumns("UserId1", "UserId2", "RoleId1", "RoleId2");
databaseMapping.Assert <UserRole>().ColumnCountEquals(4);
databaseMapping.Assert <UserRole>().HasForeignKey(new[] { "UserId1", "UserId2" }, "Users");
databaseMapping.Assert <UserRole>().HasForeignKey(new[] { "RoleId1", "RoleId2" }, "Roles");
}
public void Build_model_containing_a_complex_type_with_required_attribute()
{
var modelBuilder = new AdventureWorksModelBuilder();
modelBuilder.Entity <BillOfMaterials>();
modelBuilder.ComplexType <UnitMeasure>();
using (var typeConfiguration = new DynamicTypeDescriptionConfiguration <BillOfMaterials>())
{
typeConfiguration.SetPropertyAttributes(t => t.UnitMeasure, new RequiredAttribute());
var databaseMapping = BuildMapping(modelBuilder);
Assert.Equal(1, databaseMapping.EntityContainerMappings.Single().EntitySetMappings.Count());
Assert.Equal(1, databaseMapping.Model.ComplexTypes.Count());
}
}
public void Default_length_for_key_string_column()
{
using (var loginConfiguration = new DynamicTypeDescriptionConfiguration <Login>())
{
loginConfiguration.SetPropertyAttributes(l => l.UserName, new KeyAttribute());
var modelBuilder = new DbModelBuilder();
modelBuilder.Entity <Login>();
modelBuilder.Ignore <Profile>();
var databaseMapping = BuildMapping(modelBuilder);
databaseMapping.AssertValid();
databaseMapping.Assert <Login>(x => x.UserName)
.DbEqual("nvarchar", c => c.TypeName)
.DbEqual(128, f => f.MaxLength);
}
}
public void Required_and_ForeignKey_to_nothing()
{
using (var loginConfiguration = new DynamicTypeDescriptionConfiguration <Login>())
{
using (new DynamicTypeDescriptionConfiguration <Profile>())
{
loginConfiguration.SetPropertyAttributes(l => l.Profile, new ForeignKeyAttribute("LoginId"));
var modelBuilder = new DbModelBuilder();
modelBuilder.Entity <Login>();
modelBuilder.Entity <Profile>();
Assert.Throws <InvalidOperationException>(
() => BuildMapping(modelBuilder))
.ValidateMessage("UnableToDeterminePrincipal", typeof(Profile), typeof(Login));
}
}
}
public void NotMapped_on_new_property_with_same_name_as_in_unmapped_base_class_ignores_it()
{
using (var differentUnitConfiguration = new DynamicTypeDescriptionConfiguration <DifferentUnit>())
{
var modelBuilder = new DbModelBuilder();
differentUnitConfiguration.SetPropertyAttributes(b => b.VirtualBaseClassProperty, new NotMappedAttribute());
modelBuilder.Entity <DifferentUnit>();
var databaseMapping = BuildMapping(modelBuilder);
databaseMapping.AssertValid();
Assert.False(
databaseMapping.Model.EntityTypes.Single().Properties.Any(
p => p.Name == "VirtualBaseClassProperty"));
}
}
public void NotMapped_on_overriden_mapped_base_class_property_throws()
{
using (var unitConfiguration = new DynamicTypeDescriptionConfiguration <Unit>())
{
var modelBuilder = new DbModelBuilder();
unitConfiguration.SetPropertyAttributes(b => b.VirtualBaseClassProperty, new NotMappedAttribute());
modelBuilder.Ignore <DifferentUnit>();
modelBuilder.Entity <Unit>();
modelBuilder.Entity <BaseEntity>();
Assert.Throws <InvalidOperationException>(() => BuildMapping(modelBuilder))
.ValidateMessage(
"CannotIgnoreMappedBaseProperty",
"VirtualBaseClassProperty", "FunctionalTests.DataAnnotationScenarioTests+Unit",
"FunctionalTests.DataAnnotationScenarioTests+BaseEntity");
}
}
public void NotMapped_on_base_class_property_discovered_through_navigation_ignores_it()
{
using (var abstractBaseEntityConfiguration = new DynamicTypeDescriptionConfiguration <AbstractBaseEntity>())
{
var modelBuilder = new DbModelBuilder();
abstractBaseEntityConfiguration.SetPropertyAttributes(b => b.AbstractBaseClassProperty, new NotMappedAttribute());
modelBuilder.Entity <Unit>();
var databaseMapping = BuildMapping(modelBuilder);
databaseMapping.AssertValid();
Assert.True(databaseMapping.Model.EntityTypes.Any(e => e.Name == "AbstractBaseEntity"));
Assert.False(
databaseMapping.Model.EntityTypes.SelectMany(e => e.Properties)
.Any(p => p.Name == "AbstractBaseClassProperty"));
}
}
public void ForeignKey_to_ForeignKey()
{
using (var loginConfiguration = new DynamicTypeDescriptionConfiguration <Login>())
{
using (var profileConfiguration = new DynamicTypeDescriptionConfiguration <Profile>())
{
loginConfiguration.SetPropertyAttributes(l => l.Profile, new ForeignKeyAttribute("LoginId"));
profileConfiguration.SetPropertyAttributes(p => p.User, new ForeignKeyAttribute("ProfileId"));
var modelBuilder = new DbModelBuilder();
modelBuilder.Entity <Login>();
modelBuilder.Entity <Profile>();
Assert.Throws <InvalidOperationException>(
() => modelBuilder.Build(ProviderRegistry.Sql2008_ProviderInfo))
.ValidateMessage("UnableToDeterminePrincipal", typeof(Profile), typeof(Login));
}
}
}
public void NotMapped_on_base_class_property_ignores_it()
{
using (var baseEntityConfiguration = new DynamicTypeDescriptionConfiguration <BaseEntity>())
{
var modelBuilder = new DbModelBuilder();
baseEntityConfiguration.SetPropertyAttributes(b => b.BaseClassProperty, new NotMappedAttribute());
baseEntityConfiguration.SetPropertyAttributes(b => b.VirtualBaseClassProperty, new NotMappedAttribute());
modelBuilder.Entity <Unit>();
modelBuilder.Entity <BaseEntity>();
var databaseMapping = BuildMapping(modelBuilder);
databaseMapping.AssertValid();
Assert.False(
databaseMapping.Model.EntityTypes.SelectMany(e => e.Properties)
.Any(p => p.Name == "BaseClassProperty"));
Assert.False(
databaseMapping.Model.EntityTypes.SelectMany(e => e.Properties)
.Any(p => p.Name == "VirtualBaseClassProperty"));
}
}
public void NotMapped_on_base_class_property_ignores_it()
{
using (var baseEntityConfiguration = new DynamicTypeDescriptionConfiguration<BaseEntity>())
{
var modelBuilder = new DbModelBuilder();
baseEntityConfiguration.SetPropertyAttributes(b => b.BaseClassProperty, new NotMappedAttribute());
baseEntityConfiguration.SetPropertyAttributes(b => b.VirtualBaseClassProperty, new NotMappedAttribute());
modelBuilder.Entity<Unit>();
modelBuilder.Entity<BaseEntity>();
var databaseMapping = BuildMapping(modelBuilder);
databaseMapping.AssertValid();
Assert.False(
databaseMapping.Model.Namespaces.Single().EntityTypes.SelectMany(e => e.Properties)
.Any(p => p.Name == "BaseClassProperty"));
Assert.False(
databaseMapping.Model.Namespaces.Single().EntityTypes.SelectMany(e => e.Properties)
.Any(p => p.Name == "VirtualBaseClassProperty"));
}
}
public void Default_length_for_key_string_column()
{
using (var loginConfiguration = new DynamicTypeDescriptionConfiguration<Login>())
{
loginConfiguration.SetPropertyAttributes(l => l.UserName, new KeyAttribute());
var modelBuilder = new DbModelBuilder();
modelBuilder.Entity<Login>();
modelBuilder.Ignore<Profile>();
var databaseMapping = BuildMapping(modelBuilder);
databaseMapping.AssertValid();
databaseMapping.Assert<Login>(x => x.UserName)
.DbEqual("nvarchar", c => c.TypeName)
.DbFacetEqual(128, f => f.MaxLength);
}
}
public void Build_model_containing_a_complex_type_with_required_attribute()
{
var modelBuilder = new AdventureWorksModelBuilder();
modelBuilder.Entity<BillOfMaterials>();
modelBuilder.ComplexType<UnitMeasure>();
using (var typeConfiguration = new DynamicTypeDescriptionConfiguration<BillOfMaterials>())
{
typeConfiguration.SetPropertyAttributes(t => t.UnitMeasure, new RequiredAttribute());
var databaseMapping = BuildMapping(modelBuilder);
Assert.Equal(1, databaseMapping.EntityContainerMappings.Single().EntitySetMappings.Count());
Assert.Equal(1, databaseMapping.Model.ComplexTypes.Count());
}
}
public void Nothing_to_Required_and_ForeignKey()
{
using (var loginConfiguration = new DynamicTypeDescriptionConfiguration<Login>())
{
using (var profileConfiguration = new DynamicTypeDescriptionConfiguration<Profile>())
{
loginConfiguration.SetPropertyAttributes(l => l.Profile);
profileConfiguration.SetPropertyAttributes(p => p.User, new RequiredAttribute(),
new ForeignKeyAttribute("ProfileId"));
var modelBuilder = new DbModelBuilder();
modelBuilder.Entity<Login>();
modelBuilder.Entity<Profile>();
var databaseMapping = BuildMapping(modelBuilder);
databaseMapping.AssertValid();
var association = databaseMapping.Model.Namespaces.Single().AssociationTypes.Single();
Assert.Equal("Profile", association.SourceEnd.EntityType.Name);
Assert.Equal(EdmAssociationEndKind.Optional, association.SourceEnd.EndKind);
Assert.Equal("Login", association.TargetEnd.EntityType.Name);
Assert.Equal(EdmAssociationEndKind.Required, association.TargetEnd.EndKind);
Assert.Equal("Profile", association.Constraint.DependentEnd.EntityType.Name);
}
}
}
public void NotMapped_on_base_class_property_discovered_through_navigation_ignores_it()
{
using (var abstractBaseEntityConfiguration = new DynamicTypeDescriptionConfiguration<AbstractBaseEntity>())
{
var modelBuilder = new DbModelBuilder();
abstractBaseEntityConfiguration.SetPropertyAttributes(b => b.AbstractBaseClassProperty, new NotMappedAttribute());
modelBuilder.Entity<Unit>();
var databaseMapping = BuildMapping(modelBuilder);
databaseMapping.AssertValid();
Assert.True(databaseMapping.Model.EntityTypes.Any(e => e.Name == "AbstractBaseEntity"));
Assert.False(
databaseMapping.Model.EntityTypes.SelectMany(e => e.Properties)
.Any(p => p.Name == "AbstractBaseClassProperty"));
}
}
public void NotMapped_on_unmapped_base_class_property_and_overriden_property_ignores_it()
{
using (var unitConfiguration = new DynamicTypeDescriptionConfiguration<Unit>())
{
using (var baseEntityConfiguration = new DynamicTypeDescriptionConfiguration<BaseEntity>())
{
var modelBuilder = new DbModelBuilder();
baseEntityConfiguration.SetPropertyAttributes(b => b.VirtualBaseClassProperty, new NotMappedAttribute());
unitConfiguration.SetPropertyAttributes(b => b.VirtualBaseClassProperty, new NotMappedAttribute());
modelBuilder.Ignore<AbstractBaseEntity>();
modelBuilder.Ignore<BaseEntity>();
modelBuilder.Entity<Unit>();
var databaseMapping = BuildMapping(modelBuilder);
databaseMapping.AssertValid();
Assert.False(
databaseMapping.Model.EntityTypes.Single().Properties.Any(
p => p.Name == "VirtualBaseClassProperty"));
}
}
}
public void NotMapped_on_overriden_mapped_base_class_property_throws()
{
using (var unitConfiguration = new DynamicTypeDescriptionConfiguration<Unit>())
{
var modelBuilder = new DbModelBuilder();
unitConfiguration.SetPropertyAttributes(b => b.VirtualBaseClassProperty, new NotMappedAttribute());
modelBuilder.Ignore<DifferentUnit>();
modelBuilder.Entity<Unit>();
modelBuilder.Entity<BaseEntity>();
Assert.Throws<InvalidOperationException>(() => BuildMapping(modelBuilder))
.ValidateMessage(
"CannotIgnoreMappedBaseProperty",
"VirtualBaseClassProperty", "FunctionalTests.DataAnnotationScenarioTests+Unit",
"FunctionalTests.DataAnnotationScenarioTests+BaseEntity");
}
}
public void NotMapped_on_new_property_with_same_name_as_in_unmapped_base_class_ignores_it()
{
using (var differentUnitConfiguration = new DynamicTypeDescriptionConfiguration<DifferentUnit>())
{
var modelBuilder = new DbModelBuilder();
differentUnitConfiguration.SetPropertyAttributes(b => b.VirtualBaseClassProperty, new NotMappedAttribute());
modelBuilder.Entity<DifferentUnit>();
var databaseMapping = BuildMapping(modelBuilder);
databaseMapping.AssertValid();
Assert.False(
databaseMapping.Model.EntityTypes.Single().Properties.Any(
p => p.Name == "VirtualBaseClassProperty"));
}
}
public void Required_and_ForeignKey_to_nothing()
{
using (var loginConfiguration = new DynamicTypeDescriptionConfiguration<Login>())
{
using (new DynamicTypeDescriptionConfiguration<Profile>())
{
loginConfiguration.SetPropertyAttributes(l => l.Profile, new ForeignKeyAttribute("LoginId"));
var modelBuilder = new DbModelBuilder();
modelBuilder.Entity<Login>();
modelBuilder.Entity<Profile>();
Assert.Throws<InvalidOperationException>(
() => modelBuilder.Build(ProviderRegistry.Sql2008_ProviderInfo))
.ValidateMessage("UnableToDeterminePrincipal", typeof(Profile), typeof(Login));
}
}
}
public void Key_column_and_MaxLength_work_together()
{
using (var entityClassConfiguration = new DynamicTypeDescriptionConfiguration<ColumnKeyAnnotationClass>())
{
entityClassConfiguration.SetPropertyAttributes(c => c.PersonFirstName, new MaxLengthAttribute(64));
var modelBuilder = new DbModelBuilder();
modelBuilder.Entity<ColumnKeyAnnotationClass>();
var databaseMapping = BuildMapping(modelBuilder);
databaseMapping.AssertValid();
databaseMapping.Assert<ColumnKeyAnnotationClass>(x => x.PersonFirstName)
.DbEqual("dsdsd", c => c.Name)
.DbEqual("nvarchar", c => c.TypeName)
.DbEqual(64, f => f.MaxLength)
.DbEqual(true, c => c.IsPrimaryKeyColumn);
}
}
public void Nothing_to_Required_and_ForeignKey()
{
using (var loginConfiguration = new DynamicTypeDescriptionConfiguration<Login>())
{
using (var profileConfiguration = new DynamicTypeDescriptionConfiguration<Profile>())
{
loginConfiguration.SetPropertyAttributes(l => l.Profile);
profileConfiguration.SetPropertyAttributes(
p => p.User, new RequiredAttribute(),
new ForeignKeyAttribute("ProfileId"));
var modelBuilder = new DbModelBuilder();
modelBuilder.Entity<Login>();
modelBuilder.Entity<Profile>();
var databaseMapping = BuildMapping(modelBuilder);
databaseMapping.AssertValid();
var association = databaseMapping.Model.AssociationTypes.Single();
Assert.Equal("Profile", association.SourceEnd.GetEntityType().Name);
Assert.Equal(RelationshipMultiplicity.ZeroOrOne, association.SourceEnd.RelationshipMultiplicity);
Assert.Equal("Login", association.TargetEnd.GetEntityType().Name);
Assert.Equal(RelationshipMultiplicity.One, association.TargetEnd.RelationshipMultiplicity);
Assert.Equal("Profile", association.Constraint.ToRole.GetEntityType().Name);
}
}
}
public void Key_column_and_MaxLength_work_together_in_an_IA()
{
using (var entityClassConfiguration = new DynamicTypeDescriptionConfiguration<ColumnKeyAnnotationClass>())
{
entityClassConfiguration.SetPropertyAttributes(c => c.PersonFirstName, new MaxLengthAttribute(64));
var modelBuilder = new DbModelBuilder();
modelBuilder.Entity<ColumnKeyAnnotationClass>();
modelBuilder.Entity<ReferencingClass>();
var databaseMapping = BuildMapping(modelBuilder);
databaseMapping.AssertValid();
databaseMapping.Assert<ColumnKeyAnnotationClass>(x => x.PersonFirstName)
.DbEqual("dsdsd", c => c.Name)
.DbEqual("nvarchar", c => c.TypeName)
.DbFacetEqual(64, f => f.MaxLength)
.DbEqual(true, c => c.IsPrimaryKeyColumn);
Assert.Equal(1, databaseMapping.Model.Namespaces.Single().AssociationTypes.Count());
databaseMapping.Assert<ReferencingClass>().ForeignKeyColumn("Person_PersonFirstName")
.DbEqual("nvarchar", c => c.TypeName)
.DbFacetEqual(64, f => f.MaxLength);
}
}
public void ForeignKey_to_ForeignKey()
{
using (var loginConfiguration = new DynamicTypeDescriptionConfiguration<Login>())
{
using (var profileConfiguration = new DynamicTypeDescriptionConfiguration<Profile>())
{
loginConfiguration.SetPropertyAttributes(l => l.Profile, new ForeignKeyAttribute("LoginId"));
profileConfiguration.SetPropertyAttributes(p => p.User, new ForeignKeyAttribute("ProfileId"));
var modelBuilder = new DbModelBuilder();
modelBuilder.Entity<Login>();
modelBuilder.Entity<Profile>();
Assert.Throws<InvalidOperationException>(
() => BuildMapping(modelBuilder))
.ValidateMessage("UnableToDeterminePrincipal", typeof(Profile), typeof(Login));
}
}
}
public void ForeignKey_to_ForeignKey()
{
using (var loginConfiguration = new DynamicTypeDescriptionConfiguration<Login>())
{
using (var profileConfiguration = new DynamicTypeDescriptionConfiguration<Profile>())
{
loginConfiguration.SetPropertyAttributes(l => l.Profile, new ForeignKeyAttribute("LoginId"));
profileConfiguration.SetPropertyAttributes(p => p.User, new ForeignKeyAttribute("ProfileId"));
var modelBuilder = new DbModelBuilder();
modelBuilder.Entity<Login>();
modelBuilder.Entity<Profile>();
Assert.Equal(Strings.UnableToDeterminePrincipal(typeof(Profile), typeof(Login)),
Assert.Throws<InvalidOperationException>(
() => modelBuilder.Build(ProviderRegistry.Sql2008_ProviderInfo)).Message);
}
}
}
public void Nvarchar_column_and_MaxLength_64_produce_nvarchar_64()
{
using (var entityClassConfiguration = new DynamicTypeDescriptionConfiguration<TNAttrBase>())
{
entityClassConfiguration.SetPropertyAttributes(
c => c.BaseData,
new MaxLengthAttribute(64), new ColumnAttribute { TypeName = "nvarchar" });
using (var context = new Nvarchar64Context())
{
context.CustomOnModelCreating = modelBuilder =>
{
modelBuilder.Entity<TNAttrBase>();
var databaseMapping = BuildMapping(modelBuilder);
databaseMapping.AssertValid();
databaseMapping.Assert<TNAttrBase>(x => x.BaseData)
.DbEqual("nvarchar", c => c.TypeName)
.DbEqual(64, f => f.MaxLength)
.DbEqual(false, f => f.IsMaxLength);
};
context.Database.CreateIfNotExists();
var column = GetInfoContext(context).Columns.Single(c => c.Name == "BaseData");
Assert.Equal("nvarchar", column.Type);
Assert.Equal(64, column.MaxLength);
}
}
}
