private EntityTypeConfiguration(EntityTypeConfiguration source)
: base(source)
{
DebugCheck.NotNull(source);
_keyProperties.AddRange(source._keyProperties);
source._navigationPropertyConfigurations.Each(
c => _navigationPropertyConfigurations.Add(c.Key, c.Value.Clone()));
source._entitySubTypesMappingConfigurations.Each(
c => _entitySubTypesMappingConfigurations.Add(c.Key, c.Value.Clone()));
_entityMappingConfigurations.AddRange(
source._entityMappingConfigurations.Except(source._nonCloneableMappings).Select(e => e.Clone()));
_isKeyConfigured = source._isKeyConfigured;
_entitySetName = source._entitySetName;
if (source._modificationFunctionsConfiguration != null)
{
_modificationFunctionsConfiguration = source._modificationFunctionsConfiguration.Clone();
}
IsReplaceable = source.IsReplaceable;
IsTableNameConfigured = source.IsTableNameConfigured;
IsExplicitEntity = source.IsExplicitEntity;
}
public void Map_TDerived_should_add_mapping_configuration_to_self_if_tderived_is_same_as_tentity()
{
var entityConfiguration = new EntityTypeConfiguration<A>();
entityConfiguration.Map<A>(m => m.ToTable("A"));
Assert.Equal("A", ((EntityTypeConfiguration)entityConfiguration.Configuration).GetTableName().Name);
}
public void Configure_should_configure_modification_functions()
{
var model = new EdmModel(DataSpace.CSpace);
var entityType = model.AddEntityType("E");
entityType.GetMetadataProperties().SetClrType(typeof(object));
model.AddEntitySet("ESet", entityType);
var modificationFunctionsConfigurationMock = new Mock<ModificationStoredProceduresConfiguration>();
var entityTypeConfiguration = new EntityTypeConfiguration(typeof(object));
entityTypeConfiguration.MapToStoredProcedures(modificationFunctionsConfigurationMock.Object, true);
entityType.SetConfiguration(entityTypeConfiguration);
var databaseMapping
= new DatabaseMappingGenerator(ProviderRegistry.Sql2008_ProviderInfo, ProviderRegistry.Sql2008_ProviderManifest).Generate(model);
entityTypeConfiguration.Configure(entityType, databaseMapping, ProviderRegistry.Sql2008_ProviderManifest);
modificationFunctionsConfigurationMock
.Verify(
m => m.Configure(
It.IsAny<EntityTypeModificationFunctionMapping>(), It.IsAny<DbProviderManifest>()),
Times.Once());
}
public void Configuration_should_return_internal_configuration()
{
var entityConfiguration = new EntityTypeConfiguration<object>();
Assert.NotNull(entityConfiguration.Configuration);
Assert.Equal(typeof(EntityTypeConfiguration), entityConfiguration.Configuration.GetType());
}
internal virtual void Add(EntityTypeConfiguration entityTypeConfiguration)
{
DebugCheck.NotNull(entityTypeConfiguration);
EntityTypeConfiguration existingConfiguration;
if ((_entityConfigurations.TryGetValue(entityTypeConfiguration.ClrType, out existingConfiguration)
&& !existingConfiguration.IsReplaceable)
|| _complexTypeConfigurations.ContainsKey(entityTypeConfiguration.ClrType))
{
throw Error.DuplicateStructuralTypeConfiguration(entityTypeConfiguration.ClrType);
}
if (existingConfiguration != null
&& existingConfiguration.IsReplaceable)
{
_entityConfigurations.Remove(existingConfiguration.ClrType);
entityTypeConfiguration.ReplaceFrom(existingConfiguration);
}
else
{
entityTypeConfiguration.IsReplaceable = false;
}
_entityConfigurations.Add(entityTypeConfiguration.ClrType, entityTypeConfiguration);
}
internal override void Configure(
EdmAssociationType associationType, EdmAssociationEnd dependentEnd,
EntityTypeConfiguration entityTypeConfiguration)
{
//Contract.Requires(associationType != null);
//Contract.Requires(dependentEnd != null);
//Contract.Requires(entityTypeConfiguration != null);
}
public void HasKey_should_throw_when_invalid_key_expression()
{
var entityConfiguration = new EntityTypeConfiguration<object>();
Assert.Equal(
Strings.InvalidPropertiesExpression("o => o.ToString()"),
Assert.Throws<InvalidOperationException>(() => entityConfiguration.HasKey(o => o.ToString())).Message);
}
public void Apply_should_set_table_name()
{
var entityTypeConfiguration = new EntityTypeConfiguration(typeof(object));
new TableAttributeConvention.TableAttributeConventionImpl()
.Apply(new MockType(), entityTypeConfiguration, new TableAttribute("Foo"));
Assert.Equal("Foo", entityTypeConfiguration.GetTableName().Name);
}
public void MapToStoredProcedures_should_call_method_on_internal_configuration()
{
var mockEntityTypeConfiguration = new Mock<EntityTypeConfiguration>(typeof(Fixture));
var entityConfiguration = new EntityTypeConfiguration<Fixture>(mockEntityTypeConfiguration.Object);
entityConfiguration.MapToStoredProcedures();
mockEntityTypeConfiguration.Verify(e => e.MapToStoredProcedures());
}
public void Configure_should_set_configuration()
{
var entityType = new EntityType("E", "N", DataSpace.CSpace);
var entityTypeConfiguration = new EntityTypeConfiguration(typeof(object));
entityTypeConfiguration.Configure(entityType, new EdmModel(DataSpace.CSpace));
Assert.Same(entityTypeConfiguration, entityType.GetConfiguration());
}
public void HasKey_should_add_key_properties()
{
var mockEntityTypeConfiguration = new Mock<EntityTypeConfiguration>(typeof(Fixture));
var entityConfiguration = new EntityTypeConfiguration<Fixture>(mockEntityTypeConfiguration.Object);
entityConfiguration.HasKey(f => f.Id);
mockEntityTypeConfiguration.Verify(e => e.Key(new[] { typeof(Fixture).GetProperty("Id") }));
}
public void Map_TDerived_should_throw_for_repeat_configuration_of_derived_type()
{
var entityConfiguration = new EntityTypeConfiguration<A>();
Assert.Equal(Strings.InvalidChainedMappingSyntax("B"), Assert.Throws<InvalidOperationException>(() => entityConfiguration
.Map<A>(m => m.ToTable("A"))
.Map<B>(mb => mb.ToTable("B"))
.Map<C>(mc => mc.ToTable("C"))
.Map<B>(mb2 => mb2.ToTable("B"))).Message);
}
public void Can_pass_function_mapping_configuration_to_map_to_functions()
{
var entityTypeConfiguration = new EntityTypeConfiguration(typeof(object));
Assert.Null(entityTypeConfiguration.ModificationStoredProceduresConfiguration);
entityTypeConfiguration.MapToStoredProcedures(new ModificationStoredProceduresConfiguration(), true);
Assert.NotNull(entityTypeConfiguration.ModificationStoredProceduresConfiguration);
}
internal override void Configure(
AssociationType associationType, AssociationEndMember dependentEnd,
EntityTypeConfiguration entityTypeConfiguration)
{
DebugCheck.NotNull(associationType);
DebugCheck.NotNull(dependentEnd);
DebugCheck.NotNull(entityTypeConfiguration);
associationType.MarkIndependent();
}
public void Apply_should_ignore_property()
{
var mockPropertyInfo = new MockPropertyInfo();
var entityTypeConfiguration = new EntityTypeConfiguration(typeof(object));
new NotMappedPropertyAttributeConvention.NotMappedPropertyAttributeConventionImpl()
.Apply(mockPropertyInfo, entityTypeConfiguration, new NotMappedAttribute());
Assert.True(entityTypeConfiguration.IgnoredProperties.Contains(mockPropertyInfo));
}
public void Can_pass_function_mapping_configuration_to_map_to_functions()
{
var entityTypeConfiguration = new EntityTypeConfiguration(typeof(object));
Assert.False(entityTypeConfiguration.IsMappedToFunctions);
entityTypeConfiguration.MapToStoredProcedures(new ModificationFunctionsConfiguration());
Assert.True(entityTypeConfiguration.IsMappedToFunctions);
}
public void MapToStoredProcedures_should_create_empty_function_mapping_configuration()
{
var entityTypeConfiguration = new EntityTypeConfiguration(typeof(object));
Assert.False(entityTypeConfiguration.IsMappedToFunctions);
entityTypeConfiguration.MapToStoredProcedures();
Assert.True(entityTypeConfiguration.IsMappedToFunctions);
}
public void MapToStoredProcedures_should_create_empty_function_mapping_configuration()
{
var entityTypeConfiguration = new EntityTypeConfiguration(typeof(object));
Assert.Null(entityTypeConfiguration.ModificationStoredProceduresConfiguration);
entityTypeConfiguration.MapToStoredProcedures();
Assert.NotNull(entityTypeConfiguration.ModificationStoredProceduresConfiguration);
}
public void Apply_should_not_set_table_name_when_already_set()
{
var entityTypeConfiguration = new EntityTypeConfiguration(typeof(object));
entityTypeConfiguration.ToTable("Bar");
new TableAttributeConvention()
.Apply(new MockType(), entityTypeConfiguration, new TableAttribute("Foo"));
Assert.Equal("Bar", entityTypeConfiguration.GetTableName().Name);
}
public void Property_evaluates_preconditions()
{
var type = typeof(LocalEntityType);
var innerConfig = new EntityTypeConfiguration(type);
var config = new LightweightEntityConfiguration<object>(type, () => innerConfig);
var ex = Assert.Throws<ArgumentNullException>(
() => config.Property<object>(null));
Assert.Equal("propertyExpression", ex.ParamName);
}
public void Ignore_configures()
{
var type = typeof(LocalEntityType);
var innerConfig = new EntityTypeConfiguration(type);
var config = new LightweightEntityConfiguration<LocalEntityType>(type, () => innerConfig);
config.Ignore(t => t.Property1);
Assert.Equal(1, innerConfig.IgnoredProperties.Count());
Assert.True(innerConfig.IgnoredProperties.Any(p => p.Name == "Property1"));
}
public void Ignore_evaluates_preconditions()
{
var type = typeof(LocalEntityType);
var innerConfig = new EntityTypeConfiguration(type);
var config = new ConventionTypeConfiguration<object>(type, () => innerConfig, new ModelConfiguration());
var ex = Assert.Throws<ArgumentNullException>(
() => config.Ignore<object>(null));
Assert.Equal("propertyExpression", ex.ParamName);
}
public void HasEntitySetName_configures_when_unset()
{
var type = new MockType();
var innerConfig = new EntityTypeConfiguration(type);
var config = new LightweightEntityConfiguration(type, () => innerConfig);
var result = config.HasEntitySetName("EntitySet1");
Assert.Equal("EntitySet1", innerConfig.EntitySetName);
Assert.Same(config, result);
}
public void HasEntitySetName_evaluates_preconditions()
{
var type = new MockType();
var innerConfig = new EntityTypeConfiguration(type);
var config = new LightweightEntityConfiguration(type, () => innerConfig);
var ex = Assert.Throws<ArgumentException>(
() => config.HasEntitySetName(null));
Assert.Equal(Strings.ArgumentIsNullOrWhitespace("entitySetName"), ex.Message);
}
public void Apply_should_set_schema_name()
{
var entityTypeConfiguration = new EntityTypeConfiguration(typeof(object));
new TableAttributeConvention()
.Apply(
new ConventionTypeConfiguration(new MockType(), () => entityTypeConfiguration, new ModelConfiguration()),
new TableAttribute("Foo") { Schema = "Bar" });
Assert.Equal("Bar", entityTypeConfiguration.GetTableName().Schema);
}
public void MapToStoredProcedures_when_config_action_should_call_method_on_internal_configuration()
{
var mockEntityTypeConfiguration = new Mock<EntityTypeConfiguration>(typeof(Fixture));
var entityConfiguration = new EntityTypeConfiguration<Fixture>(mockEntityTypeConfiguration.Object);
ModificationFunctionsConfiguration<Fixture> configuration = null;
entityConfiguration.MapToStoredProcedures(c => { configuration = c; });
mockEntityTypeConfiguration.Verify(e => e.MapToStoredProcedures(configuration.Configuration, true));
}
public void Apply_does_not_invoke_action_when_no_predicates_and_different_type()
{
var actionInvoked = false;
var convention = new EntityConventionOfType<LocalType1>(
Enumerable.Empty<Func<Type, bool>>(),
c => actionInvoked = true);
var type = typeof(object);
var configuration = new EntityTypeConfiguration(type);
convention.Apply(type, () => configuration);
Assert.False(actionInvoked);
}
public void Apply_invokes_action_when_predicate_true_and_same_type()
{
var actionInvoked = false;
var convention = new EntityConventionOfType<LocalType1>(
new Func<Type, bool>[] { t => true },
c => actionInvoked = true);
var type = typeof(LocalType1);
var configuration = new EntityTypeConfiguration(type);
convention.Apply(type, () => configuration);
Assert.True(actionInvoked);
}
public void Apply_invokes_action_when_no_predicates()
{
var actionInvoked = false;
var convention = new EntityConvention(
Enumerable.Empty<Func<Type, bool>>(),
c => actionInvoked = true);
var type = new MockType();
var configuration = new EntityTypeConfiguration(type);
convention.Apply(type, () => configuration);
Assert.True(actionInvoked);
}
public void Apply_does_not_invoke_action_when_single_predicate_false()
{
var actionInvoked = false;
var convention = new EntityConvention(
new Func<Type, bool>[] { t => false },
c => actionInvoked = true);
var type = new MockType();
var configuration = new EntityTypeConfiguration(type);
convention.Apply(type, () => configuration);
Assert.False(actionInvoked);
}
