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); }