public void Apply_adds_fk_column_when_nav_prop_is_valid()
{
var mockTypeA = new MockType("A");
var mockTypeB = new MockType("B").Property <int>("AId").Property(mockTypeA, "A");
var mockPropertyInfo = mockTypeB.GetProperty("AId");
var mockNavigationPropertyInfo = mockTypeB.GetProperty("A");
var modelConfiguration = new ModelConfiguration();
new ForeignKeyPrimitivePropertyAttributeConvention()
.Apply(
mockPropertyInfo,
new ConventionTypeConfiguration(mockTypeB, () => modelConfiguration.Entity(mockTypeB), modelConfiguration),
new ForeignKeyAttribute("A"));
var navigationPropertyConfiguration
= modelConfiguration.Entity(mockTypeB).Navigation(mockNavigationPropertyInfo);
Assert.NotNull(navigationPropertyConfiguration.Constraint);
var foreignKeyConstraint = (ForeignKeyConstraintConfiguration)navigationPropertyConfiguration.Constraint;
Assert.Equal(new[] { mockTypeB.GetProperty("AId") }, foreignKeyConstraint.ToProperties);
Assert.Null(navigationPropertyConfiguration.InverseNavigationProperty);
}
public void Apply_ignores_constraint_when_inverse_constraint_already_specified()
{
var mockPropertyInfo = typeof(AType4).GetInstanceProperty("B");
var mockInversePropertyInfo = typeof(BType4).GetInstanceProperty("A");
var modelConfiguration = new ModelConfiguration();
var navigationPropertyConfiguration
= modelConfiguration.Entity(typeof(AType4)).Navigation(mockPropertyInfo);
var inverseNavigationPropertyConfiguration
= modelConfiguration.Entity(typeof(BType4)).Navigation(mockInversePropertyInfo);
navigationPropertyConfiguration.InverseNavigationProperty = mockInversePropertyInfo;
inverseNavigationPropertyConfiguration.Constraint
= new ForeignKeyConstraintConfiguration(new[] { typeof(BType4).GetInstanceProperty("AId1") });
new ForeignKeyPrimitivePropertyAttributeConvention()
.Apply(
typeof(BType4).GetInstanceProperty("AId1"),
new ConventionTypeConfiguration(typeof(BType4), () => modelConfiguration.Entity(typeof(BType4)), modelConfiguration),
new ForeignKeyAttribute("A"));
Assert.Null(navigationPropertyConfiguration.Constraint);
}
public void Apply_ignores_constraint_when_inverse_constraint_already_specified()
{
var mockTypeA = new MockType("A");
var mockTypeB = new MockType("B").Property(mockTypeA, "A").Property <int>("AId1").Property <int>("AId2");
mockTypeA.Property(mockTypeB, "B");
var mockPropertyInfo = mockTypeA.GetProperty("B");
var mockInversePropertyInfo = mockTypeB.GetProperty("A");
var modelConfiguration = new ModelConfiguration();
var navigationPropertyConfiguration
= modelConfiguration.Entity(mockTypeA).Navigation(mockPropertyInfo);
var inverseNavigationPropertyConfiguration
= modelConfiguration.Entity(mockTypeB).Navigation(mockInversePropertyInfo);
navigationPropertyConfiguration.InverseNavigationProperty = mockInversePropertyInfo;
inverseNavigationPropertyConfiguration.Constraint
= new ForeignKeyConstraintConfiguration(new[] { mockTypeB.GetProperty("AId1") });
new ForeignKeyPrimitivePropertyAttributeConvention()
.Apply(mockPropertyInfo, modelConfiguration, new ForeignKeyAttribute("AId2"));
Assert.Null(navigationPropertyConfiguration.Constraint);
}
private bool HasConfiguredConstraint()
{
if (_configuration != null &&
_configuration.Constraint != null &&
_configuration.Constraint.IsFullySpecified)
{
return(true);
}
if (_configuration != null &&
_configuration.InverseNavigationProperty != null)
{
var targetType = _configuration.NavigationProperty.PropertyType.GetTargetType();
if (_modelConfiguration.Entities.Contains(targetType))
{
var entityConfiguration = _modelConfiguration.Entity(targetType);
if (entityConfiguration.IsNavigationPropertyConfigured(_configuration.InverseNavigationProperty))
{
return(entityConfiguration.Navigation(_configuration.InverseNavigationProperty)
.Constraint != null);
}
}
}
return(false);
}
public void Apply_finds_inverse_when_many_to_many()
{
var propertyInfo = typeof(BType2).GetInstanceProperty("As");
var modelConfiguration = new ModelConfiguration();
new InversePropertyAttributeConvention()
.Apply(
propertyInfo,
new ConventionTypeConfiguration(typeof(BType2), () => modelConfiguration.Entity(typeof(BType2)), modelConfiguration),
new InversePropertyAttribute("Bs"));
var navigationPropertyConfiguration
= modelConfiguration.Entity(typeof(BType2)).Navigation(propertyInfo);
Assert.Same(typeof(AType2).GetInstanceProperty("Bs"), navigationPropertyConfiguration.InverseNavigationProperty);
}
public void Apply_ignores_inverse_when_already_configured()
{
var propertyInfo = typeof(AType4).GetInstanceProperty("B");
var modelConfiguration = new ModelConfiguration();
var navigationPropertyConfiguration
= modelConfiguration.Entity(typeof(AType4)).Navigation(propertyInfo);
navigationPropertyConfiguration.InverseNavigationProperty = typeof(BType4).GetInstanceProperty("A2");
new InversePropertyAttributeConvention()
.Apply(
propertyInfo,
new ConventionTypeConfiguration(typeof(AType4), () => modelConfiguration.Entity(typeof(AType4)), modelConfiguration),
new InversePropertyAttribute("A1"));
Assert.NotSame(typeof(BType4).GetInstanceProperty("A1"), navigationPropertyConfiguration.InverseNavigationProperty);
}
public static void ConfigureEdmMetadata(ModelConfiguration modelConfiguration)
{
DebugCheck.NotNull(modelConfiguration);
#pragma warning disable 612,618
modelConfiguration.Entity(typeof(EdmMetadata)).ToTable(TableName);
#pragma warning restore 612,618
}
public void Build_should_validate_and_throw_with_invalid_model()
{
var modelConfiguration = new ModelConfiguration();
modelConfiguration.Entity(typeof(Random), true);
Assert.Throws <ModelValidationException>(
() => new DbModelBuilder(modelConfiguration).Build(ProviderRegistry.Sql2008_ProviderInfo));
}
public void Add_entity_configuration_should_add_to_model_configuration()
{
var modelConfiguration = new ModelConfiguration();
var entityConfiguration = new EntityTypeConfiguration <object>();
new ConfigurationRegistrar(modelConfiguration).Add(entityConfiguration);
Assert.Same(entityConfiguration.Configuration, modelConfiguration.Entity(typeof(object)));
}
public void Add_entity_configuration_should_add_to_model_configuration()
{
var modelConfiguration = new ModelConfiguration();
var entityConfiguration = new EntityTypeConfiguration<object>();
new ConfigurationRegistrar(modelConfiguration).Add(entityConfiguration);
Assert.Same(entityConfiguration.Configuration, modelConfiguration.Entity(typeof(object)));
}
public void Apply_ignores_constraint_when_already_specified()
{
var propertyInfo = typeof(BType3).GetInstanceProperty("A");
var modelConfiguration = new ModelConfiguration();
var navigationPropertyConfiguration
= modelConfiguration.Entity(typeof(BType3)).Navigation(propertyInfo);
navigationPropertyConfiguration.Constraint
= new ForeignKeyConstraintConfiguration(new[] { typeof(BType3).GetInstanceProperty("AId1") });
new ForeignKeyPrimitivePropertyAttributeConvention()
.Apply(
typeof(BType3).GetInstanceProperty("AId2"),
new ConventionTypeConfiguration(typeof(BType3), () => modelConfiguration.Entity(typeof(BType3)), modelConfiguration),
new ForeignKeyAttribute("A"));
var foreignKeyConstraint = (ForeignKeyConstraintConfiguration)navigationPropertyConfiguration.Constraint;
Assert.Equal(new[] { typeof(BType3).GetInstanceProperty("AId1") }, foreignKeyConstraint.ToProperties);
}
public void Apply_finds_inverse_when_many_to_many()
{
var mockTypeA = new MockType("A");
var mockTypeB = new MockType("B").Property(mockTypeA.AsCollection(), "As");
var mockPropertyInfo = mockTypeB.GetProperty("As");
mockTypeA.Property(mockTypeB.AsCollection(), "Bs");
var modelConfiguration = new ModelConfiguration();
new InversePropertyAttributeConvention()
.Apply(
mockPropertyInfo,
new ConventionTypeConfiguration(mockTypeB, () => modelConfiguration.Entity(mockTypeB), modelConfiguration),
new InversePropertyAttribute("Bs"));
var navigationPropertyConfiguration
= modelConfiguration.Entity(mockTypeB).Navigation(mockPropertyInfo);
Assert.Same(mockTypeA.GetProperty("Bs"), navigationPropertyConfiguration.InverseNavigationProperty);
}
public void Mapping_a_single_abstract_type_should_not_throw()
{
var modelConfiguration = new ModelConfiguration();
modelConfiguration.Entity(typeof(AType1)).Key(typeof(AType1).GetDeclaredProperty("Id"));
var modelBuilder = new DbModelBuilder();
var databaseMapping = modelBuilder.Build(ProviderRegistry.Sql2008_ProviderInfo);
Assert.NotNull(databaseMapping);
}
public void IsIgnoredProperty_should_return_true_if_property_is_ignored()
{
var modelConfiguration = new ModelConfiguration();
var mockType = new MockType();
var mockPropertyInfo = new MockPropertyInfo(typeof(string), "S");
Assert.False(modelConfiguration.IsIgnoredProperty(mockType, mockPropertyInfo));
modelConfiguration.Entity(mockType).Ignore(mockPropertyInfo);
Assert.True(modelConfiguration.IsIgnoredProperty(mockType, mockPropertyInfo));
}
public void Mapping_a_single_abstract_type_should_not_throw()
{
var modelConfiguration = new ModelConfiguration();
var mockType = new MockType("T").TypeAttributes(TypeAttributes.Abstract).Property <int>("Id");
modelConfiguration.Entity(mockType).Key(mockType.GetProperty("Id"));
var modelBuilder = new DbModelBuilder();
var databaseMapping = modelBuilder.Build(ProviderRegistry.Sql2008_ProviderInfo);
Assert.NotNull(databaseMapping);
}
public void Apply_ignores_inverse_when_already_configured()
{
var mockTypeA = new MockType("A");
var mockTypeB = new MockType("B").Property(mockTypeA, "A1").Property(mockTypeA, "A2");
mockTypeA.Property(mockTypeB, "B");
var mockPropertyInfo = mockTypeA.GetProperty("B");
var modelConfiguration = new ModelConfiguration();
var navigationPropertyConfiguration
= modelConfiguration.Entity(mockTypeA).Navigation(mockPropertyInfo);
navigationPropertyConfiguration.InverseNavigationProperty = mockTypeB.GetProperty("A2");
new InversePropertyAttributeConvention()
.Apply(
mockPropertyInfo,
new ConventionTypeConfiguration(mockTypeA, () => modelConfiguration.Entity(mockTypeA), modelConfiguration),
new InversePropertyAttribute("A1"));
Assert.NotSame(mockTypeB.GetProperty("A1"), navigationPropertyConfiguration.InverseNavigationProperty);
}
public void GetConfiguredProperties_should_return_all_configured_properties()
{
var modelConfiguration = new ModelConfiguration();
var mockType = new MockType();
var mockPropertyInfo = new MockPropertyInfo(typeof(string), "S");
Assert.False(modelConfiguration.GetConfiguredProperties(mockType).Any());
modelConfiguration.Entity(mockType).Property(new PropertyPath(mockPropertyInfo));
Assert.Same(mockPropertyInfo.Object, modelConfiguration.GetConfiguredProperties(mockType).Single());
}
public void Apply_ignores_inverse_on_nonnavigation()
{
var propertyInfo = typeof(AType5).GetInstanceProperty("B");
var modelConfiguration = new ModelConfiguration();
var entityConfiguration = modelConfiguration.Entity(typeof(AType5));
new InversePropertyAttributeConvention()
.Apply(
propertyInfo, new ConventionTypeConfiguration(typeof(AType5), () => entityConfiguration, modelConfiguration),
new InversePropertyAttribute("A1"));
Assert.False(entityConfiguration.IsNavigationPropertyConfigured(propertyInfo));
}
public void MapEntityType_with_configured_Entity_should_throw_with_StoreInline()
{
var type = typeof(TypeMapper_EntityWithStoreInline);
var model = new EdmModel(DataSpace.CSpace);
var modelConfiguration = new ModelConfiguration();
modelConfiguration.Entity(typeof(TypeMapper_EntityWithStoreInline));
var typeMapper = new TypeMapper(new MappingContext(modelConfiguration, new ConventionsConfiguration(), model));
Assert.Equal(
Strings.ComplexTypeConfigurationMismatch(type.Name),
Assert.Throws <InvalidOperationException>(() => typeMapper.MapEntityType(type)).Message);
}
public void Apply_ignores_inverse_on_nonnavigation()
{
var mockTypeA = new MockType("A").Property(typeof(int), "B");
var mockPropertyInfo = mockTypeA.GetProperty("B");
var modelConfiguration = new ModelConfiguration();
var entityConfiguration = modelConfiguration.Entity(mockTypeA);
new InversePropertyAttributeConvention()
.Apply(
mockPropertyInfo, new ConventionTypeConfiguration(mockTypeA, () => entityConfiguration, modelConfiguration),
new InversePropertyAttribute("A1"));
Assert.False(entityConfiguration.IsNavigationPropertyConfigured(mockPropertyInfo));
}
public void Apply_adds_fk_column_when_nav_prop_is_valid()
{
var propertyInfo = typeof(BType2).GetInstanceProperty("AId");
var navigationPropertyInfo = typeof(BType2).GetInstanceProperty("A");
var modelConfiguration = new ModelConfiguration();
new ForeignKeyPrimitivePropertyAttributeConvention()
.Apply(
propertyInfo,
new ConventionTypeConfiguration(typeof(BType2), () => modelConfiguration.Entity(typeof(BType2)), modelConfiguration),
new ForeignKeyAttribute("A"));
var navigationPropertyConfiguration
= modelConfiguration.Entity(typeof(BType2)).Navigation(navigationPropertyInfo);
Assert.NotNull(navigationPropertyConfiguration.Constraint);
var foreignKeyConstraint = (ForeignKeyConstraintConfiguration)navigationPropertyConfiguration.Constraint;
Assert.Equal(new[] { typeof(BType2).GetInstanceProperty("AId") }, foreignKeyConstraint.ToProperties);
Assert.Null(navigationPropertyConfiguration.InverseNavigationProperty);
}
public void Apply_throws_when_cannot_find_navigation_property()
{
var modelConfiguration = new ModelConfiguration();
Assert.Equal(
Strings.ForeignKeyAttributeConvention_InvalidNavigationProperty("BId", typeof(AType1), "Missing"),
Assert.Throws <InvalidOperationException>(
() => new ForeignKeyPrimitivePropertyAttributeConvention()
.Apply(
typeof(AType1).GetInstanceProperty("BId"),
new ConventionTypeConfiguration(
typeof(AType1), () => modelConfiguration.Entity(typeof(AType1)), modelConfiguration),
new ForeignKeyAttribute("Missing"))).Message);
}
public void MapEntityType_recognizes_TableName()
{
var type = typeof(TypeMapper_EntityWithTableName);
var model = new EdmModel(DataSpace.CSpace);
var modelConfiguration = new ModelConfiguration();
var typeMapper = new TypeMapper(new MappingContext(modelConfiguration, new ConventionsConfiguration(), model));
typeMapper.MapEntityType(type);
Assert.False(modelConfiguration.IsComplexType(type));
Assert.Equal(1, model.EntityTypes.Count());
Assert.Equal(0, model.ComplexTypes.Count());
Assert.Equal("Foo", modelConfiguration.Entity(typeof(TypeMapper_EntityWithTableName)).GetTableName().Name);
}
public void Apply_ignores_constraint_when_already_specified()
{
var mockTypeA = new MockType("A");
var mockTypeB = new MockType("B").Property <int>("AId1").Property <int>("AId2");
mockTypeB.Property(mockTypeA, "A");
var mockPropertyInfo = mockTypeB.GetProperty("A");
var modelConfiguration = new ModelConfiguration();
var navigationPropertyConfiguration
= modelConfiguration.Entity(mockTypeB).Navigation(mockPropertyInfo);
navigationPropertyConfiguration.Constraint
= new ForeignKeyConstraintConfiguration(new[] { mockTypeB.GetProperty("AId1") });
new ForeignKeyPrimitivePropertyAttributeConvention()
.Apply(
mockTypeB.GetProperty("AId2"),
new ConventionTypeConfiguration(mockTypeB, () => modelConfiguration.Entity(mockTypeB), modelConfiguration),
new ForeignKeyAttribute("A"));
var foreignKeyConstraint = (ForeignKeyConstraintConfiguration)navigationPropertyConfiguration.Constraint;
Assert.Equal(new[] { mockTypeB.GetProperty("AId1") }, foreignKeyConstraint.ToProperties);
}
public void Apply_throws_when_cannot_find_inverse_property()
{
var propertyInfo = typeof(AType7).GetInstanceProperty("B");
var modelConfiguration = new ModelConfiguration();
Assert.Equal(
Strings.InversePropertyAttributeConvention_PropertyNotFound("Foo", typeof(BType7), "B", typeof(AType7)),
Assert.Throws <InvalidOperationException>(
() => new InversePropertyAttributeConvention()
.Apply(
propertyInfo,
new ConventionTypeConfiguration(
typeof(AType7), () => modelConfiguration.Entity(typeof(AType7)), modelConfiguration),
new InversePropertyAttribute("Foo"))).Message);
}
public void Build_should_map_types()
{
var modelConfiguration = new ModelConfiguration();
var mockType = new MockType("T").Property <int>("Id");
modelConfiguration.Entity(mockType).Key(mockType.GetProperty("Id"));
modelConfiguration.ComplexType(new MockType("C"));
var modelBuilder = new DbModelBuilder(modelConfiguration);
var databaseMapping = modelBuilder.Build(ProviderRegistry.Sql2008_ProviderInfo).DatabaseMapping;
Assert.NotNull(databaseMapping);
Assert.Equal(1, databaseMapping.Model.GetEntityTypes().Count());
Assert.Equal(1, databaseMapping.Model.GetComplexTypes().Count());
}
public void Apply_throws_on_self_inverse()
{
var propertyInfo = typeof(AType6).GetInstanceProperty("A");
var modelConfiguration = new ModelConfiguration();
Assert.Equal(
Strings.InversePropertyAttributeConvention_SelfInverseDetected("A", typeof(AType6)),
Assert.Throws <InvalidOperationException>(
() => new InversePropertyAttributeConvention()
.Apply(
propertyInfo,
new ConventionTypeConfiguration(
typeof(AType6), () => modelConfiguration.Entity(typeof(AType6)), modelConfiguration),
new InversePropertyAttribute("A"))).Message);
}
public void Build_should_map_types()
{
var modelConfiguration = new ModelConfiguration();
modelConfiguration.Entity(typeof(AType2)).Key(typeof(AType2).GetInstanceProperty("Id"));
modelConfiguration.ComplexType(typeof(CType2));
var modelBuilder = new DbModelBuilder(modelConfiguration);
var databaseMapping = modelBuilder.Build(ProviderRegistry.Sql2008_ProviderInfo).DatabaseMapping;
Assert.NotNull(databaseMapping);
Assert.Equal(1, databaseMapping.Model.EntityTypes.Count());
Assert.Equal(1, databaseMapping.Model.ComplexTypes.Count());
}
public void Build_should_apply_model_configuration()
{
var modelConfiguration = new ModelConfiguration();
modelConfiguration.Entity(typeof(AType1))
.Property(new PropertyPath(typeof(AType1).GetInstanceProperty("Id")))
.ConcurrencyMode = ConcurrencyMode.Fixed;
var databaseMapping = new DbModelBuilder(modelConfiguration).Build(ProviderRegistry.Sql2008_ProviderInfo).DatabaseMapping;
Assert.NotNull(databaseMapping);
Assert.Equal(
ConcurrencyMode.Fixed,
databaseMapping.Model.EntityTypes.Single().DeclaredProperties.Single().ConcurrencyMode);
}
public void Build_should_apply_model_configuration()
{
var modelConfiguration = new ModelConfiguration();
var mockType = new MockType("T").Property <int>("Id");
modelConfiguration.Entity(mockType)
.Property(new PropertyPath(mockType.GetProperty("Id")))
.ConcurrencyMode = ConcurrencyMode.Fixed;
var databaseMapping = new DbModelBuilder(modelConfiguration).Build(ProviderRegistry.Sql2008_ProviderInfo).DatabaseMapping;
Assert.NotNull(databaseMapping);
Assert.Equal(
ConcurrencyMode.Fixed,
databaseMapping.Model.Namespaces.Single().EntityTypes.Single().DeclaredProperties.Single().ConcurrencyMode);
}
public void Apply_finds_inverse_when_optional_to_optional()
{
var mockTypeA = new MockType("A");
var mockTypeB = new MockType("B").Property(mockTypeA, "A");
var mockPropertyInfo = mockTypeB.GetProperty("A");
mockTypeA.Property(mockTypeB, "B");
var modelConfiguration = new ModelConfiguration();
new InversePropertyAttributeConvention()
.Apply(mockPropertyInfo, modelConfiguration, new InversePropertyAttribute("B"));
var navigationPropertyConfiguration
= modelConfiguration.Entity(mockTypeB).Navigation(mockPropertyInfo);
Assert.Same(mockTypeA.GetProperty("B"), navigationPropertyConfiguration.InverseNavigationProperty);
}
public void HasConstraint_is_noop_when_set_on_inverse()
{
var modelConfiguration = new ModelConfiguration();
var inverseNavigationProperty = typeof(LightweighEntity).GetDeclaredProperty("PrivateNavigationProperty");
modelConfiguration.Entity(typeof(LightweighEntity))
.Navigation(inverseNavigationProperty)
.Constraint = IndependentConstraintConfiguration.Instance;
var configuration =
new NavigationPropertyConfiguration(
typeof(LightweighEntity).GetDeclaredProperty("ValidNavigationProperty"));
configuration.InverseNavigationProperty = inverseNavigationProperty;
var lightweightConfiguration = new ConventionNavigationPropertyConfiguration(configuration, modelConfiguration);
lightweightConfiguration.HasConstraint <ForeignKeyConstraintConfiguration>();
Assert.Null(configuration.Constraint);
}
public void Apply_throws_on_self_inverse()
{
var mockTypeA = new MockType("A");
mockTypeA.Property(mockTypeA, "A");
var mockPropertyInfo = mockTypeA.GetProperty("A");
var modelConfiguration = new ModelConfiguration();
Assert.Equal(
Strings.InversePropertyAttributeConvention_SelfInverseDetected("A", mockTypeA.Object),
Assert.Throws <InvalidOperationException>(
() => new InversePropertyAttributeConvention()
.Apply(
mockPropertyInfo,
new ConventionTypeConfiguration(
mockTypeA, () => modelConfiguration.Entity(mockTypeA), modelConfiguration),
new InversePropertyAttribute("A"))).Message);
}
public void HasConstraint_is_noop_when_set_on_inverse()
{
var modelConfiguration = new ModelConfiguration();
var inverseNavigationProperty = typeof(LightweighEntity).GetDeclaredProperty("PrivateNavigationProperty");
modelConfiguration.Entity(typeof(LightweighEntity))
.Navigation(inverseNavigationProperty)
.Constraint = IndependentConstraintConfiguration.Instance;
var configuration =
new NavigationPropertyConfiguration(
typeof(LightweighEntity).GetDeclaredProperty("ValidNavigationProperty"));
configuration.InverseNavigationProperty = inverseNavigationProperty;
var lightweightConfiguration = new ConventionNavigationPropertyConfiguration(configuration, modelConfiguration);
lightweightConfiguration.HasConstraint < ForeignKeyConstraintConfiguration>();
Assert.Null(configuration.Constraint);
}
public void Configure_entity_splitting_should_throw_if_ignored_property_is_mapped()
{
EdmModel model =
new TestModelBuilder()
.Entity("E")
.Key("P1");
var databaseMapping = new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest).Generate(model);
var entityType = model.GetEntityType("E");
var modelConfiguration = new ModelConfiguration();
var entityConfiguration = modelConfiguration.Entity(entityType.GetClrType());
var p1PropertyInfo = entityType.GetDeclaredPrimitiveProperty("P1").GetClrPropertyInfo();
var entityMappingConfiguration1 =
new EntityMappingConfiguration
{
Properties = new List<PropertyPath>
{
new PropertyPath(p1PropertyInfo),
new PropertyPath(new MockPropertyInfo(typeof(int), "P2"))
},
TableName = new DatabaseName("E")
};
entityConfiguration.AddMappingConfiguration(entityMappingConfiguration1);
Assert.Equal(
Strings.EntityMappingConfiguration_CannotMapIgnoredProperty("E", "P2"),
Assert.Throws<InvalidOperationException>(
() => modelConfiguration.Configure(databaseMapping, ProviderRegistry.Sql2008_ProviderManifest)).Message);
}
public void ConfiguredTypes_returns_all_known_types()
{
var modelConfiguration = new ModelConfiguration();
modelConfiguration.Entity(new MockType());
modelConfiguration.ComplexType(new MockType());
modelConfiguration.Ignore(new MockType());
Assert.Equal(3, modelConfiguration.ConfiguredTypes.Count());
}
public void Can_add_and_get_entity_configuration()
{
var modelConfiguration = new ModelConfiguration();
var entityTypeConfiguration = new Mock<EntityTypeConfiguration>(typeof(object)).Object;
modelConfiguration.Add(entityTypeConfiguration);
Assert.Same(entityTypeConfiguration, modelConfiguration.Entity(typeof(object)));
}
public void ComplexTypes_returns_only_configured_non_ignored_complex_types()
{
var modelConfiguration = new ModelConfiguration();
modelConfiguration.Entity(new MockType());
var mockComplexType = new MockType();
modelConfiguration.ComplexType(mockComplexType);
var mockIgnoredComplexType = new MockType();
modelConfiguration.ComplexType(mockIgnoredComplexType);
modelConfiguration.Ignore(mockIgnoredComplexType);
Assert.Same(mockComplexType.Object, modelConfiguration.ComplexTypes.Single());
}
public void Configure_mapping_can_process_entity_splitting()
{
EdmModel model =
new TestModelBuilder()
.Entity("E")
.Key("P1")
.Property("P2")
.Property("P3")
.Property("P4")
.Property("P5");
var databaseMapping = new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest).Generate(model);
var entityType = model.GetEntityType("E");
var modelConfiguration = new ModelConfiguration();
var entityMappingConfiguration1 =
new EntityMappingConfiguration
{
Properties =
new List<PropertyPath>
{
new PropertyPath(entityType.GetDeclaredPrimitiveProperty("P1").GetClrPropertyInfo()),
new PropertyPath(entityType.GetDeclaredPrimitiveProperty("P2").GetClrPropertyInfo()),
new PropertyPath(entityType.GetDeclaredPrimitiveProperty("P3").GetClrPropertyInfo())
},
TableName = new DatabaseName("E1")
};
var entityMappingConfiguration2 =
new EntityMappingConfiguration
{
Properties =
new List<PropertyPath>
{
new PropertyPath(entityType.GetDeclaredPrimitiveProperty("P1").GetClrPropertyInfo()),
new PropertyPath(entityType.GetDeclaredPrimitiveProperty("P4").GetClrPropertyInfo()),
new PropertyPath(entityType.GetDeclaredPrimitiveProperty("P5").GetClrPropertyInfo())
},
TableName = new DatabaseName("E2")
};
var entityConfiguration = modelConfiguration.Entity(entityType.GetClrType());
entityConfiguration.AddMappingConfiguration(entityMappingConfiguration1);
entityConfiguration.AddMappingConfiguration(entityMappingConfiguration2);
modelConfiguration.Configure(databaseMapping, ProviderRegistry.Sql2008_ProviderManifest);
var entityTypeMapping = databaseMapping.GetEntityTypeMapping(entityType);
var table1 = entityTypeMapping.TypeMappingFragments[0].Table;
var table2 = entityTypeMapping.TypeMappingFragments[1].Table;
Assert.NotSame(table1, table2);
Assert.Equal("E1", table1.GetTableName().Name);
Assert.Equal("E2", table2.GetTableName().Name);
Assert.Equal(3, table1.Columns.Count);
Assert.Equal(3, table2.Columns.Count);
Assert.Equal(2, entityTypeMapping.TypeMappingFragments.Count);
var entityTypeMappingFragment1 = entityTypeMapping.TypeMappingFragments[0];
var entityTypeMappingFragment2 = entityTypeMapping.TypeMappingFragments[1];
Assert.Equal(3, entityTypeMappingFragment1.PropertyMappings.Count);
Assert.Equal("P1", entityTypeMappingFragment1.PropertyMappings[0].Column.Name);
Assert.Equal("P2", entityTypeMappingFragment1.PropertyMappings[1].Column.Name);
Assert.Equal("P3", entityTypeMappingFragment1.PropertyMappings[2].Column.Name);
Assert.Equal(3, entityTypeMappingFragment2.PropertyMappings.Count);
Assert.Equal("P1", entityTypeMappingFragment2.PropertyMappings[0].Column.Name);
Assert.Equal("P4", entityTypeMappingFragment2.PropertyMappings[1].Column.Name);
Assert.Equal("P5", entityTypeMappingFragment2.PropertyMappings[2].Column.Name);
}
public void Entity_should_return_new_configuration_if_no_configuration_found()
{
var modelConfiguration = new ModelConfiguration();
Assert.NotNull(modelConfiguration.Entity(typeof(object)));
}
public void Configure_mapping_can_process_one_level_TPH_on_both_sides_of_tree()
{
//Setup
var model = TestModelBuilderHelpers.CreateSingleLevelInheritanceWithThreeEntities();
var databaseMapping = new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest).Generate(model);
var entityType1 = model.GetEntityType("E1");
var entityType2 = model.GetEntityType("E2");
var entityType3 = model.GetEntityType("E3");
// Action
var modelConfiguration = new ModelConfiguration();
var entity1Configuration = modelConfiguration.Entity(entityType1.GetClrType());
var entity1MappingConfiguration =
new EntityMappingConfiguration
{
TableName = new DatabaseName("E1")
};
entity1MappingConfiguration
.AddValueCondition(
new ValueConditionConfiguration(entity1MappingConfiguration, "P3")
{
Value = null
});
entity1MappingConfiguration
.AddValueCondition(
new ValueConditionConfiguration(entity1MappingConfiguration, "P4")
{
Value = null
});
entity1Configuration.AddMappingConfiguration(entity1MappingConfiguration);
var entity1SubTypeMappingConfiguration =
new EntityMappingConfiguration
{
TableName = new DatabaseName("E1")
};
entity1SubTypeMappingConfiguration
.AddValueCondition(
new ValueConditionConfiguration(entity1SubTypeMappingConfiguration, "P3")
{
Value = null
});
entity1SubTypeMappingConfiguration
.AddNullabilityCondition(
new NotNullConditionConfiguration(
entity1SubTypeMappingConfiguration,
new PropertyPath(entityType3.GetDeclaredPrimitiveProperty("P4").GetClrPropertyInfo())));
entity1Configuration.AddSubTypeMappingConfiguration(entityType3.GetClrType(), entity1SubTypeMappingConfiguration);
var entity2Configuration = modelConfiguration.Entity(entityType2.GetClrType());
var entity2MappingConfiguration =
new EntityMappingConfiguration
{
TableName = new DatabaseName("E1")
};
entity2MappingConfiguration
.AddNullabilityCondition(
new NotNullConditionConfiguration(
entity2MappingConfiguration, new PropertyPath(entityType2.GetDeclaredPrimitiveProperty("P3").GetClrPropertyInfo())));
entity2MappingConfiguration
.AddValueCondition(
new ValueConditionConfiguration(entity2MappingConfiguration, "P4")
{
Value = null
});
entity2Configuration.AddMappingConfiguration(entity2MappingConfiguration);
modelConfiguration.NormalizeConfigurations();
modelConfiguration.Configure(databaseMapping, ProviderRegistry.Sql2008_ProviderManifest);
//Validate
var entitySetMapping = databaseMapping.GetEntitySetMapping(model.GetEntitySet(entityType1));
Assert.NotNull(entitySetMapping);
Assert.Equal(4, entitySetMapping.EntityTypeMappings.Count);
var entityType1Mapping = databaseMapping.GetEntityTypeMapping(entityType1);
var entityType1MappingConditions = databaseMapping.GetEntityTypeMappings(entityType1).Single(x => !x.IsHierarchyMapping);
var entityType2Mapping = databaseMapping.GetEntityTypeMapping(entityType2);
var entityType3Mapping = databaseMapping.GetEntityTypeMapping(entityType3);
var table1 = entityType1Mapping.TypeMappingFragments.Single().Table;
var table2 = entityType2Mapping.TypeMappingFragments.Single().Table;
var table3 = entityType3Mapping.TypeMappingFragments.Single().Table;
Assert.True(entityType1Mapping.IsHierarchyMapping);
Assert.Equal(4, table1.Columns.Count);
Assert.Equal("P1", table1.Columns[0].Name);
Assert.Equal("P2", table1.Columns[1].Name);
Assert.Equal("P3", table1.Columns[2].Name);
Assert.Equal("P4", table1.Columns[3].Name);
Assert.Equal(2, entityType1Mapping.TypeMappingFragments.Single().PropertyMappings.Count);
Assert.Equal("P1", entityType1Mapping.TypeMappingFragments.Single().PropertyMappings[0].Column.Name);
Assert.Equal("P2", entityType1Mapping.TypeMappingFragments.Single().PropertyMappings[1].Column.Name);
Assert.Same(table1.Columns[2], entityType1MappingConditions.TypeMappingFragments.Single().ColumnConditions[0].Column);
Assert.True((bool)entityType1MappingConditions.TypeMappingFragments.Single().ColumnConditions[0].IsNull);
Assert.Same(table1.Columns[3], entityType1MappingConditions.TypeMappingFragments.Single().ColumnConditions[1].Column);
Assert.True((bool)entityType1MappingConditions.TypeMappingFragments.Single().ColumnConditions[1].IsNull);
Assert.False(entityType2Mapping.IsHierarchyMapping);
Assert.Same(table1, table2);
Assert.Same(table1.Columns[0], table2.Columns[0]);
Assert.Same(table1.Columns[1], table2.Columns[1]);
Assert.Equal(2, entityType2Mapping.TypeMappingFragments.Single().PropertyMappings.Count);
Assert.Equal("P1", entityType2Mapping.TypeMappingFragments.Single().PropertyMappings[0].Column.Name);
Assert.Equal("P3", entityType2Mapping.TypeMappingFragments.Single().PropertyMappings[1].Column.Name);
Assert.Same(table1.Columns[3], entityType2Mapping.TypeMappingFragments.Single().ColumnConditions[0].Column);
Assert.True((bool)entityType2Mapping.TypeMappingFragments.Single().ColumnConditions[0].IsNull);
Assert.Same(table1.Columns[2], entityType2Mapping.TypeMappingFragments.Single().ColumnConditions[1].Column);
Assert.False((bool)entityType2Mapping.TypeMappingFragments.Single().ColumnConditions[1].IsNull);
Assert.False(entityType3Mapping.IsHierarchyMapping);
Assert.Same(table1, table3);
Assert.Same(table1.Columns[0], table3.Columns[0]);
Assert.Same(table1.Columns[1], table3.Columns[1]);
Assert.Equal(2, entityType3Mapping.TypeMappingFragments.Single().PropertyMappings.Count);
Assert.Equal("P1", entityType3Mapping.TypeMappingFragments.Single().PropertyMappings[0].Column.Name);
Assert.Equal("P4", entityType3Mapping.TypeMappingFragments.Single().PropertyMappings[1].Column.Name);
Assert.Same(table1.Columns[2], entityType3Mapping.TypeMappingFragments.Single().ColumnConditions[0].Column);
Assert.True((bool)entityType3Mapping.TypeMappingFragments.Single().ColumnConditions[0].IsNull);
Assert.Same(table1.Columns[3], entityType3Mapping.TypeMappingFragments.Single().ColumnConditions[1].Column);
Assert.False((bool)entityType3Mapping.TypeMappingFragments.Single().ColumnConditions[1].IsNull);
}
public void Configure_mapping_can_process_simple_TPH_mapping()
{
//Setup
var model = TestModelBuilderHelpers.CreateSimpleInheritanceTwoEntities();
var databaseMapping = new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest).Generate(model);
var entityType1 = model.GetEntityType("E1");
var entityType2 = model.GetEntityType("E2");
// Action
var modelConfiguration = new ModelConfiguration();
var entity1Configuration = modelConfiguration.Entity(entityType1.GetClrType());
var entity1MappingConfiguration =
new EntityMappingConfiguration
{
TableName = new DatabaseName("E1")
};
entity1MappingConfiguration
.AddValueCondition(
new ValueConditionConfiguration(entity1MappingConfiguration, "disc")
{
Value = "foo"
});
entity1Configuration.AddMappingConfiguration(entity1MappingConfiguration);
var entity1SubTypeMappingConfiguration =
new EntityMappingConfiguration
{
TableName = new DatabaseName("E1")
};
entity1SubTypeMappingConfiguration
.AddValueCondition(
new ValueConditionConfiguration(entity1SubTypeMappingConfiguration, "disc")
{
Value = "bar"
});
entity1Configuration.AddSubTypeMappingConfiguration(entityType2.GetClrType(), entity1SubTypeMappingConfiguration);
modelConfiguration.NormalizeConfigurations();
modelConfiguration.Configure(databaseMapping, ProviderRegistry.Sql2008_ProviderManifest);
//Validate
var entitySetMapping = databaseMapping.GetEntitySetMapping(model.GetEntitySet(entityType1));
Assert.NotNull(entitySetMapping);
Assert.Equal(3, entitySetMapping.EntityTypeMappings.Count);
var entityType1Mapping = databaseMapping.GetEntityTypeMapping(entityType1);
var entityType1MappingConditions = databaseMapping.GetEntityTypeMappings(entityType1).Single(tm => !tm.IsHierarchyMapping);
var entityType2Mapping = databaseMapping.GetEntityTypeMapping(entityType2);
var table1 = entityType1Mapping.TypeMappingFragments.Single().Table;
var table2 = entityType2Mapping.TypeMappingFragments.Single().Table;
Assert.True(entityType1Mapping.IsHierarchyMapping);
Assert.Equal(4, table1.Columns.Count);
Assert.Equal("P1", table1.Columns[0].Name);
Assert.Equal("P2", table1.Columns[1].Name);
Assert.Equal("P3", table1.Columns[2].Name);
Assert.Equal("disc", table1.Columns[3].Name);
Assert.Equal(2, entityType1Mapping.TypeMappingFragments.Single().PropertyMappings.Count);
Assert.Equal("P1", entityType1Mapping.TypeMappingFragments.Single().PropertyMappings[0].Column.Name);
Assert.Equal("P2", entityType1Mapping.TypeMappingFragments.Single().PropertyMappings[1].Column.Name);
Assert.Same(table1.Columns[3], entityType1MappingConditions.TypeMappingFragments.Single().ColumnConditions.Single().Column);
Assert.Equal("foo", entityType1MappingConditions.TypeMappingFragments.Single().ColumnConditions.Single().Value);
Assert.Equal("nvarchar", entityType1MappingConditions.TypeMappingFragments.Single().ColumnConditions.Single().Column.TypeName);
Assert.Equal(
DatabaseMappingGenerator.DiscriminatorLength,
entityType1MappingConditions.TypeMappingFragments.Single().ColumnConditions.Single().Column.Facets.MaxLength);
Assert.False(entityType2Mapping.IsHierarchyMapping);
Assert.Same(table1, table2);
Assert.Equal(2, entityType2Mapping.TypeMappingFragments.Single().PropertyMappings.Count);
Assert.Same(table1.Columns[0], table2.Columns[0]);
Assert.Same(table1.Columns[1], table2.Columns[1]);
Assert.Equal("P1", entityType2Mapping.TypeMappingFragments.Single().PropertyMappings[0].Column.Name);
Assert.Equal("P3", entityType2Mapping.TypeMappingFragments.Single().PropertyMappings[1].Column.Name);
Assert.Same(table2.Columns[3], entityType2Mapping.TypeMappingFragments.Single().ColumnConditions.Single().Column);
Assert.Equal("bar", entityType2Mapping.TypeMappingFragments.Single().ColumnConditions.Single().Value);
}
public void Entity_should_throw_when_configuration_is_not_for_entity()
{
var modelConfiguration = new ModelConfiguration();
modelConfiguration.Add(new Mock<ComplexTypeConfiguration>(typeof(object)).Object);
Assert.Equal(
Strings.EntityTypeConfigurationMismatch(typeof(object)),
Assert.Throws<InvalidOperationException>(() => modelConfiguration.Entity(typeof(object))).Message);
}
public void Configure_mapping_can_process_one_level_TPC_on_both_sides_of_tree()
{
//Setup
var model = TestModelBuilderHelpers.CreateSingleLevelInheritanceWithThreeEntities();
var databaseMapping = new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest).Generate(model);
var entityType1 = model.GetEntityType("E1");
var entityType2 = model.GetEntityType("E2");
var entityType3 = model.GetEntityType("E3");
// Action
var modelConfiguration = new ModelConfiguration();
modelConfiguration.Entity(entityType2.GetClrType())
.AddMappingConfiguration(
new EntityMappingConfiguration
{
MapInheritedProperties = true,
TableName = new DatabaseName("E2")
});
modelConfiguration.Entity(entityType3.GetClrType())
.AddMappingConfiguration(
new EntityMappingConfiguration
{
MapInheritedProperties = true,
TableName = new DatabaseName("E3")
});
modelConfiguration.Configure(databaseMapping, ProviderRegistry.Sql2008_ProviderManifest);
//Validate
var entitySetMapping = databaseMapping.GetEntitySetMapping(model.GetEntitySet(entityType1));
Assert.NotNull(entitySetMapping);
Assert.Equal(3, entitySetMapping.EntityTypeMappings.Count);
var entityType1Mapping = databaseMapping.GetEntityTypeMapping(entityType1);
var entityType2Mapping = databaseMapping.GetEntityTypeMapping(entityType2);
var entityType3Mapping = databaseMapping.GetEntityTypeMapping(entityType3);
var table1 = entityType1Mapping.TypeMappingFragments.Single().Table;
var table2 = entityType2Mapping.TypeMappingFragments.Single().Table;
var table3 = entityType3Mapping.TypeMappingFragments.Single().Table;
Assert.False(entityType1Mapping.IsHierarchyMapping);
Assert.Equal(2, table1.Columns.Count);
Assert.Equal("P1", table1.Columns[0].Name);
Assert.Equal("P2", table1.Columns[1].Name);
Assert.Equal(2, entityType1Mapping.TypeMappingFragments.Single().PropertyMappings.Count);
Assert.Same(entityType1Mapping.TypeMappingFragments.Single().PropertyMappings[0].Column, table1.Columns[0]);
Assert.Same(entityType1Mapping.TypeMappingFragments.Single().PropertyMappings[1].Column, table1.Columns[1]);
Assert.False(entityType2Mapping.IsHierarchyMapping);
Assert.Equal("E2", table2.Name);
Assert.Equal(3, table2.Columns.Count);
Assert.Equal("P1", table2.Columns[0].Name);
Assert.Equal("P2", table2.Columns[1].Name);
Assert.Equal("P3", table2.Columns[2].Name);
Assert.NotSame(table1, table2);
Assert.NotSame(table1.Columns[0], table2.Columns[0]);
Assert.NotSame(table1.Columns[1], table2.Columns[1]);
Assert.Equal(3, entityType2Mapping.TypeMappingFragments.Single().PropertyMappings.Count);
Assert.Same(entityType2Mapping.TypeMappingFragments.Single().PropertyMappings[0].Column, table2.Columns[0]);
Assert.Same(entityType2Mapping.TypeMappingFragments.Single().PropertyMappings[1].Column, table2.Columns[1]);
Assert.Same(entityType2Mapping.TypeMappingFragments.Single().PropertyMappings[2].Column, table2.Columns[2]);
Assert.False(entityType3Mapping.IsHierarchyMapping);
Assert.Equal("E3", table3.Name);
Assert.Equal(3, table3.Columns.Count);
Assert.Equal("P1", table3.Columns[0].Name);
Assert.Equal("P2", table3.Columns[1].Name);
Assert.Equal("P4", table3.Columns[2].Name);
Assert.NotSame(table1, table3);
Assert.NotSame(table3, table2);
Assert.NotSame(table1.Columns[0], table3.Columns[0]);
Assert.NotSame(table1.Columns[1], table3.Columns[1]);
Assert.Equal(3, entityType3Mapping.TypeMappingFragments.Single().PropertyMappings.Count);
Assert.Same(entityType3Mapping.TypeMappingFragments.Single().PropertyMappings[0].Column, table3.Columns[0]);
Assert.Same(entityType3Mapping.TypeMappingFragments.Single().PropertyMappings[1].Column, table3.Columns[1]);
Assert.Same(entityType3Mapping.TypeMappingFragments.Single().PropertyMappings[2].Column, table3.Columns[2]);
}
public void Configure_mapping_can_configure_one_level_TPT_on_both_sides_of_tree()
{
//Setup
var model = TestModelBuilderHelpers.CreateSingleLevelInheritanceWithThreeEntities();
var entityType1 = model.GetEntityType("E1");
var entityType2 = model.GetEntityType("E2");
var entityType3 = model.GetEntityType("E3");
entityType1.GetDeclaredPrimitiveProperty("P1").SetStoreGeneratedPattern(DbStoreGeneratedPattern.Identity);
var databaseMapping = new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderManifest).Generate(model);
var modelConfiguration = new ModelConfiguration();
modelConfiguration.Entity(entityType2.GetClrType()).ToTable("E2");
modelConfiguration.Entity(entityType3.GetClrType()).ToTable("E3");
modelConfiguration.Configure(databaseMapping, ProviderRegistry.Sql2008_ProviderManifest);
var entityTypeMapping1 = databaseMapping.GetEntityTypeMapping(entityType1);
var entityTypeMapping2 = databaseMapping.GetEntityTypeMapping(entityType2);
var entityTypeMapping3 = databaseMapping.GetEntityTypeMapping(entityType3);
var table1 = entityTypeMapping1.TypeMappingFragments.Single().Table;
var table2 = entityTypeMapping2.TypeMappingFragments.Single().Table;
var table3 = entityTypeMapping3.TypeMappingFragments.Single().Table;
Assert.NotSame(table1, table2);
Assert.NotSame(table1, table3);
Assert.NotSame(table3, table2);
Assert.True(entityTypeMapping1.IsHierarchyMapping);
Assert.Equal(2, table1.Columns.Count);
Assert.Equal("P1", table1.Columns[0].Name);
Assert.Equal(DbStoreGeneratedPattern.Identity, table1.Columns[0].StoreGeneratedPattern);
Assert.Equal("P2", table1.Columns[1].Name);
Assert.Equal(2, entityTypeMapping1.TypeMappingFragments.Single().PropertyMappings.Count);
Assert.Equal("P1", entityTypeMapping1.TypeMappingFragments.Single().PropertyMappings[0].Column.Name);
Assert.Equal("P2", entityTypeMapping1.TypeMappingFragments.Single().PropertyMappings[1].Column.Name);
Assert.False(entityTypeMapping2.IsHierarchyMapping);
Assert.Equal(2, entityTypeMapping2.TypeMappingFragments.Single().PropertyMappings.Count);
Assert.Equal("P1", entityTypeMapping2.TypeMappingFragments.Single().PropertyMappings[0].Column.Name);
Assert.Equal(DbStoreGeneratedPattern.None, table2.Columns[0].StoreGeneratedPattern);
Assert.Equal("P3", entityTypeMapping2.TypeMappingFragments.Single().PropertyMappings[1].Column.Name);
Assert.Equal(2, table2.Columns.Count);
Assert.Equal("P1", table2.Columns[0].Name);
Assert.Equal("P3", table2.Columns[1].Name);
Assert.NotSame(table1.Columns[0], table2.Columns[0]);
Assert.False(entityTypeMapping3.IsHierarchyMapping);
Assert.Equal(2, entityTypeMapping3.TypeMappingFragments.Single().PropertyMappings.Count);
Assert.Equal(DbStoreGeneratedPattern.None, table3.Columns[0].StoreGeneratedPattern);
Assert.Equal("P1", entityTypeMapping3.TypeMappingFragments.Single().PropertyMappings[0].Column.Name);
Assert.Equal("P4", entityTypeMapping3.TypeMappingFragments.Single().PropertyMappings[1].Column.Name);
Assert.Equal(2, table3.Columns.Count);
Assert.Equal("P1", table3.Columns[0].Name);
Assert.Equal("P4", table3.Columns[1].Name);
Assert.NotSame(table1.Columns[0], table3.Columns[0]);
Assert.NotSame(table2.Columns[0], table3.Columns[0]);
}
