public void AddAfter_should_throw_when_after_convention_not_found()
{
var mockConvention = new Mock<IConvention>();
var conventionsConfiguration = new ConventionsConfiguration();
Assert.Equal(Strings.ConventionNotFound(mockConvention.Object.GetType(), typeof(ConventionFixture)), Assert.Throws<InvalidOperationException>(() => conventionsConfiguration.AddAfter<ConventionFixture>(mockConvention.Object)).Message);
}
private DbModelBuilder(DbModelBuilder source)
{
DebugCheck.NotNull(source);
_modelConfiguration = source._modelConfiguration.Clone();
_conventionsConfiguration = source._conventionsConfiguration.Clone();
_modelBuilderVersion = source._modelBuilderVersion;
}
public void Configure_evaluates_preconditions()
{
var conventions = new ConventionsConfiguration();
var entities = new EntityConventionConfiguration(conventions);
var ex = Assert.Throws<ArgumentNullException>(
() => entities.Having<object>(t => null).Configure(null));
Assert.Equal("entityConfigurationAction", ex.ParamName);
}
public void Having_evaluates_preconditions()
{
var conventions = new ConventionsConfiguration();
var properties = new PropertyConventionConfiguration(conventions);
var ex = Assert.Throws<ArgumentNullException>(
() => properties.Having<object>(null));
Assert.Equal("capturingPredicate", ex.ParamName);
}
public void Configure_evaluates_preconditions()
{
var conventions = new ConventionsConfiguration();
var properties = new PropertyConventionConfiguration(conventions);
var ex = Assert.Throws<ArgumentNullException>(
() => properties.Configure(null));
Assert.Equal("propertyConfigurationAction", ex.ParamName);
}
public void Where_evaluates_preconditions()
{
var conventions = new ConventionsConfiguration();
var entities = new TypeConventionConfiguration(conventions);
var ex = Assert.Throws<ArgumentNullException>(
() => entities.Where(null));
Assert.Equal("predicate", ex.ParamName);
}
public void ApplyPropertyConfiguration_should_run_property_configuration_conventions()
{
var mockConvention = new Mock <IConfigurationConvention <PropertyInfo, StringPropertyConfiguration> >();
var conventionsConfiguration = new ConventionsConfiguration(new[] { mockConvention.Object });
var mockPropertyInfo = new MockPropertyInfo(typeof(string), "S");
conventionsConfiguration.ApplyPropertyConfiguration(mockPropertyInfo, () => new StringPropertyConfiguration());
mockConvention.Verify(c => c.Apply(mockPropertyInfo, It.IsAny <Func <StringPropertyConfiguration> >()), Times.AtMostOnce());
}
public void ApplyModelConfiguration_should_run_type_model_configuration_conventions()
{
var mockConvention = new Mock <IConfigurationConvention <Type, ModelConfiguration> >();
var conventionsConfiguration = new ConventionsConfiguration(new[] { mockConvention.Object });
var modelConfiguration = new ModelConfiguration();
conventionsConfiguration.ApplyModelConfiguration(typeof(object), modelConfiguration);
mockConvention.Verify(c => c.Apply(typeof(object), It.IsAny <Func <ModelConfiguration> >()), Times.AtMostOnce());
}
public void ApplyModelConfiguration_should_run_model_configuration_conventions()
{
var mockConvention = new Mock <IConfigurationConvention>();
var conventionsConfiguration = new ConventionsConfiguration(new[] { mockConvention.Object });
var modelConfiguration = new ModelConfiguration();
conventionsConfiguration.ApplyModelConfiguration(modelConfiguration);
mockConvention.Verify(c => c.Apply(modelConfiguration), Times.Once());
}
public void ApplyModel_should_run_model_conventions()
{
var model = new EdmModel().Initialize();
var mockConvention = new Mock<IEdmConvention>();
var conventionsConfiguration = new ConventionsConfiguration(new[] { mockConvention.Object });
conventionsConfiguration.ApplyModel(model);
mockConvention.Verify(c => c.Apply(model), Times.AtMostOnce());
}
public void ApplyDatabase_should_run_database_conventions()
{
var database = new DbDatabaseMetadata().Initialize();
var mockConvention = new Mock<IDbConvention>();
var conventionsConfiguration = new ConventionsConfiguration(new[] { mockConvention.Object });
conventionsConfiguration.ApplyDatabase(database);
mockConvention.Verify(c => c.Apply(database), Times.AtMostOnce());
}
public void Having_evaluates_preconditions()
{
var conventions = new ConventionsConfiguration();
var entities = new TypeConventionConfiguration <object>(conventions);
var ex = Assert.Throws <ArgumentNullException>(
() => entities.Having <object>(null));
Assert.Equal("capturingPredicate", ex.ParamName);
}
public void Where_evaluates_preconditions()
{
var conventions = new ConventionsConfiguration();
var entities = new EntityConventionOfTypeConfiguration <object>(conventions);
var ex = Assert.Throws <ArgumentNullException>(
() => entities.Where(null));
Assert.Equal("predicate", ex.ParamName);
}
public void ApplyDatabase_should_run_database_conventions()
{
var database = new EdmModel().Initialize();
var mockConvention = new Mock <IDbConvention>();
var conventionsConfiguration = new ConventionsConfiguration(new[] { mockConvention.Object });
conventionsConfiguration.ApplyDatabase(database);
mockConvention.Verify(c => c.Apply(database), Times.AtMostOnce());
}
public void AddAfter_should_add_after_existing_convention()
{
var mockConvention = new Mock<IConvention>();
var conventionsConfiguration = new ConventionsConfiguration(new[] { new ConventionFixture() });
conventionsConfiguration.AddAfter<ConventionFixture>(mockConvention.Object);
Assert.Equal(2, conventionsConfiguration.Conventions.Count());
Assert.Same(mockConvention.Object, conventionsConfiguration.Conventions.Last());
}
public void ApplyModel_should_run_model_conventions()
{
var model = new EdmModel().Initialize();
var mockConvention = new Mock <IEdmConvention>();
var conventionsConfiguration = new ConventionsConfiguration(new[] { mockConvention.Object });
conventionsConfiguration.ApplyModel(model);
mockConvention.Verify(c => c.Apply(model), Times.AtMostOnce());
}
public void AddBefore_should_add_before_existing_convention()
{
var mockConvention = new Mock <IConvention>();
var conventionsConfiguration = new ConventionsConfiguration(new[] { new ConventionFixture() });
conventionsConfiguration.AddBefore <ConventionFixture>(mockConvention.Object);
Assert.Equal(2, conventionsConfiguration.Conventions.Count());
Assert.Same(mockConvention.Object, conventionsConfiguration.Conventions.First());
}
public void AddAfter_should_throw_when_after_convention_not_found()
{
var mockConvention = new Mock <IConvention>();
var conventionsConfiguration = new ConventionsConfiguration();
Assert.Equal(
Strings.ConventionNotFound(mockConvention.Object.GetType(), typeof(ConventionFixture)),
Assert.Throws <InvalidOperationException>(() => conventionsConfiguration.AddAfter <ConventionFixture>(mockConvention.Object)).
Message);
}
public void Configure_evaluates_preconditions()
{
var conventions = new ConventionsConfiguration();
var entities = new TypeConventionConfiguration <object>(conventions);
var ex = Assert.Throws <ArgumentNullException>(
() => entities.Having <object>(t => null).Configure(null));
Assert.Equal("entityConfigurationAction", ex.ParamName);
}
public void Add_should_append_convention_on_to_internal_list()
{
var mockConvention1 = new Mock <IConvention>();
var mockConvention2 = new Mock <IConvention>();
var conventionsConfiguration = new ConventionsConfiguration(new[] { mockConvention1.Object });
conventionsConfiguration.Add(mockConvention2.Object);
Assert.Equal(2, conventionsConfiguration.Conventions.Count());
Assert.Same(mockConvention2.Object, conventionsConfiguration.Conventions.Last());
}
public void Add_should_append_convention_on_to_internal_list()
{
var mockConvention1 = new Mock<IConvention>();
var mockConvention2 = new Mock<IConvention>();
var conventionsConfiguration = new ConventionsConfiguration(new[] { mockConvention1.Object });
conventionsConfiguration.Add(mockConvention2.Object);
Assert.Equal(2, conventionsConfiguration.Conventions.Count());
Assert.Same(mockConvention2.Object, conventionsConfiguration.Conventions.Last());
}
public void ApplyPropertyConfiguration_should_run_property_model_conventions()
{
var mockConvention = new Mock <IConfigurationConvention <PropertyInfo, ModelConfiguration> >();
var conventionsConfiguration = new ConventionsConfiguration(
new IConvention[] { mockConvention.Object });
var mockPropertyInfo = new MockPropertyInfo(typeof(object), "N");
var modelConfiguration = new ModelConfiguration();
conventionsConfiguration.ApplyPropertyConfiguration(mockPropertyInfo, modelConfiguration);
mockConvention.Verify(c => c.Apply(mockPropertyInfo, It.IsAny <Func <ModelConfiguration> >()), Times.AtMostOnce());
}
private DbModelBuilder(
System.Data.Entity.ModelConfiguration.Configuration.ModelConfiguration modelConfiguration,
ConventionsConfiguration conventionsConfiguration,
DbModelBuilderVersion modelBuilderVersion = DbModelBuilderVersion.Latest)
{
if (!Enum.IsDefined(typeof(DbModelBuilderVersion), (object)modelBuilderVersion))
{
throw new ArgumentOutOfRangeException(nameof(modelBuilderVersion));
}
this._modelConfiguration = modelConfiguration;
this._conventionsConfiguration = conventionsConfiguration;
this._modelBuilderVersion = modelBuilderVersion;
}
public MappingContext(
System.Data.Entity.ModelConfiguration.Configuration.ModelConfiguration modelConfiguration,
ConventionsConfiguration conventionsConfiguration,
EdmModel model,
DbModelBuilderVersion modelBuilderVersion = DbModelBuilderVersion.Latest,
AttributeProvider attributeProvider = null)
{
this._modelConfiguration = modelConfiguration;
this._conventionsConfiguration = conventionsConfiguration;
this._model = model;
this._modelBuilderVersion = modelBuilderVersion;
this._attributeProvider = attributeProvider ?? new AttributeProvider();
}
public void ApplyTypeConfiguration_should_run_type_configuration_conventions()
{
var mockConvention1 = new Mock <IConfigurationConvention <Type, EntityTypeConfiguration> >();
var mockConvention2 = new Mock <IConfigurationConvention <Type, StructuralTypeConfiguration> >();
var conventionsConfiguration = new ConventionsConfiguration(
new IConvention[] { mockConvention1.Object, mockConvention2.Object });
var entityTypeConfiguration = new Func <EntityTypeConfiguration>(() => new EntityTypeConfiguration(typeof(object)));
conventionsConfiguration.ApplyTypeConfiguration(typeof(object), entityTypeConfiguration);
mockConvention1.Verify(c => c.Apply(typeof(object), entityTypeConfiguration), Times.AtMostOnce());
mockConvention2.Verify(c => c.Apply(typeof(object), entityTypeConfiguration), Times.AtMostOnce());
}
public MappingContext(
ModelConfiguration modelConfiguration,
ConventionsConfiguration conventionsConfiguration,
EdmModel model)
{
DebugCheck.NotNull(modelConfiguration);
DebugCheck.NotNull(conventionsConfiguration);
DebugCheck.NotNull(model);
_modelConfiguration = modelConfiguration;
_conventionsConfiguration = conventionsConfiguration;
_model = model;
_attributeProvider = new AttributeProvider();
}
public MappingContext(
ModelConfiguration modelConfiguration,
ConventionsConfiguration conventionsConfiguration,
EdmModel model)
{
//Contract.Requires(modelConfiguration != null);
//Contract.Requires(conventionsConfiguration != null);
//Contract.Requires(model != null);
_modelConfiguration = modelConfiguration;
_conventionsConfiguration = conventionsConfiguration;
_model = model;
_attributeProvider = new AttributeProvider();
}
public void ApplyPropertyTypeConfiguration_should_run_property_type_configuration_conventions()
{
var mockConvention1 = new Mock <IConfigurationConvention <PropertyInfo, ComplexTypeConfiguration> >();
var mockConvention2 = new Mock <IConfigurationConvention <PropertyInfo, StructuralTypeConfiguration> >();
var conventionsConfiguration = new ConventionsConfiguration(
new IConvention[] { mockConvention1.Object, mockConvention2.Object });
var complexTypeConfiguration = new Func <ComplexTypeConfiguration>(() => new ComplexTypeConfiguration(typeof(object)));
var mockPropertyInfo = new MockPropertyInfo();
conventionsConfiguration.ApplyPropertyTypeConfiguration(mockPropertyInfo, complexTypeConfiguration);
mockConvention1.Verify(c => c.Apply(mockPropertyInfo, complexTypeConfiguration), Times.AtMostOnce());
mockConvention2.Verify(c => c.Apply(mockPropertyInfo, complexTypeConfiguration), Times.AtMostOnce());
}
public void ApplyModel_should_run_targeted_model_conventions()
{
var model = new EdmModel().Initialize();
var entityType = model.AddEntityType("E");
var mockConvention = new Mock <IEdmConvention <EntityType> >();
var conventionsConfiguration = new ConventionsConfiguration(
new IConvention[]
{
mockConvention.Object
});
conventionsConfiguration.ApplyModel(model);
mockConvention.Verify(c => c.Apply(entityType, model), Times.AtMostOnce());
}
public void ApplyPropertyConfiguration_should_run_navigation_property_configuration_conventions()
{
var mockConvention1 = new Mock <IConfigurationConvention <PropertyInfo, PropertyConfiguration> >();
var mockConvention2 = new Mock <IConfigurationConvention <PropertyInfo, NavigationPropertyConfiguration> >();
var conventionsConfiguration = new ConventionsConfiguration(
new IConvention[] { mockConvention1.Object, mockConvention2.Object });
var mockPropertyInfo = new MockPropertyInfo(typeof(object), "N");
conventionsConfiguration.ApplyPropertyConfiguration(
mockPropertyInfo,
() => new NavigationPropertyConfiguration(mockPropertyInfo));
mockConvention1.Verify(c => c.Apply(mockPropertyInfo, It.IsAny <Func <PropertyConfiguration> >()), Times.AtMostOnce());
mockConvention2.Verify(c => c.Apply(mockPropertyInfo, It.IsAny <Func <NavigationPropertyConfiguration> >()), Times.AtMostOnce());
}
public void ApplyDatabase_should_run_targeted_model_conventions()
{
var database = new EdmModel().Initialize();
var table = database.AddTable("T");
var mockConvention = new Mock <IDbConvention <EntityType> >();
var conventionsConfiguration = new ConventionsConfiguration(
new IConvention[]
{
mockConvention.Object
});
conventionsConfiguration.ApplyDatabase(database);
mockConvention.Verify(c => c.Apply(table, database), Times.AtMostOnce());
}
public void ApplyPropertyConfiguration_should_run_compatible_property_configuration_conventions()
{
var mockConvention1 = new Mock <IConfigurationConvention <PropertyInfo, StringPropertyConfiguration> >();
var mockConvention2 = new Mock <IConfigurationConvention <PropertyInfo, PropertyConfiguration> >();
var mockConvention3 = new Mock <IConfigurationConvention <PropertyInfo, NavigationPropertyConfiguration> >();
var conventionsConfiguration = new ConventionsConfiguration(
new IConvention[] { mockConvention1.Object, mockConvention2.Object, mockConvention3.Object });
var mockPropertyInfo = new MockPropertyInfo(typeof(string), "S");
conventionsConfiguration.ApplyPropertyConfiguration(mockPropertyInfo, () => new StringPropertyConfiguration());
mockConvention1.Verify(c => c.Apply(mockPropertyInfo, It.IsAny <Func <StringPropertyConfiguration> >()), Times.AtMostOnce());
mockConvention2.Verify(c => c.Apply(mockPropertyInfo, It.IsAny <Func <PropertyConfiguration> >()), Times.AtMostOnce());
mockConvention3.Verify(c => c.Apply(mockPropertyInfo, It.IsAny <Func <NavigationPropertyConfiguration> >()), Times.Never());
}
public void Where_configures_predicates()
{
Func<Type, bool> predicate1 = t => true;
Func<Type, bool> predicate2 = t => false;
var conventions = new ConventionsConfiguration();
var entities = new TypeConventionConfiguration(conventions);
var config = entities
.Where(predicate1)
.Where(predicate2);
Assert.NotNull(config);
Assert.Same(conventions, config.ConventionsConfiguration);
Assert.Equal(2, config.Predicates.Count());
Assert.Same(predicate2, config.Predicates.Last());
}
public void Where_configures_predicates()
{
Func <Type, bool> predicate1 = t => true;
Func <Type, bool> predicate2 = t => false;
var conventions = new ConventionsConfiguration();
var entities = new TypeConventionConfiguration <object>(conventions);
var config = entities
.Where(predicate1)
.Where(predicate2);
Assert.IsType <TypeConventionConfiguration <object> >(config);
Assert.Same(conventions, config.ConventionsConfiguration);
Assert.Equal(2, config.Predicates.Count());
Assert.Same(predicate2, config.Predicates.Last());
}
public void Where_configures_predicates()
{
Func<PropertyInfo, bool> predicate1 = p => true;
Func<PropertyInfo, bool> predicate2 = p => false;
var conventions = new ConventionsConfiguration();
var properties = new PropertyConventionConfiguration(conventions);
var config = properties
.Where(predicate1)
.Where(predicate2);
Assert.NotNull(config);
Assert.Same(conventions, config.ConventionsConfiguration);
Assert.Equal(2, config.Predicates.Count());
Assert.Same(predicate2, config.Predicates.Last());
}
private DbModelBuilder(
ModelConfiguration.Configuration.ModelConfiguration modelConfiguration,
ConventionsConfiguration conventionsConfiguration,
DbModelBuilderVersion modelBuilderVersion = DbModelBuilderVersion.Latest)
{
DebugCheck.NotNull(modelConfiguration);
DebugCheck.NotNull(conventionsConfiguration);
if (!(Enum.IsDefined(typeof(DbModelBuilderVersion), modelBuilderVersion)))
{
throw new ArgumentOutOfRangeException("modelBuilderVersion");
}
_modelConfiguration = modelConfiguration;
_conventionsConfiguration = conventionsConfiguration;
_modelBuilderVersion = modelBuilderVersion;
}
public void Having_configures_capturing_predicate()
{
var conventions = new ConventionsConfiguration();
var entities = new EntityConventionOfTypeConfiguration<object>(conventions);
Func<Type, bool> predicate = t => true;
Func<Type, object> capturingPredicate = t => null;
var config = entities
.Where(predicate)
.Having(capturingPredicate);
Assert.IsType<EntityConventionOfTypeWithHavingConfiguration<object, object>>(config);
Assert.Same(conventions, config.ConventionsConfiguration);
Assert.Equal(1, config.Predicates.Count());
Assert.Same(predicate, config.Predicates.Single());
Assert.Same(capturingPredicate, config.CapturingPredicate);
}
public MappingContext(
ModelConfiguration modelConfiguration,
ConventionsConfiguration conventionsConfiguration,
EdmModel model,
DbModelBuilderVersion modelBuilderVersion = DbModelBuilderVersion.Latest,
AttributeProvider attributeProvider = null)
{
DebugCheck.NotNull(modelConfiguration);
DebugCheck.NotNull(conventionsConfiguration);
DebugCheck.NotNull(model);
_modelConfiguration = modelConfiguration;
_conventionsConfiguration = conventionsConfiguration;
_model = model;
_modelBuilderVersion = modelBuilderVersion;
_attributeProvider = attributeProvider ?? new AttributeProvider();
}
public void Having_configures_capturing_predicate()
{
var conventions = new ConventionsConfiguration();
var entities = new TypeConventionConfiguration <object>(conventions);
Func <Type, bool> predicate = t => true;
Func <Type, object> capturingPredicate = t => null;
var config = entities
.Where(predicate)
.Having(capturingPredicate);
Assert.IsType <TypeConventionWithHavingConfiguration <object, object> >(config);
Assert.Same(conventions, config.ConventionsConfiguration);
Assert.Equal(1, config.Predicates.Count());
Assert.Same(predicate, config.Predicates.Single());
Assert.Same(capturingPredicate, config.CapturingPredicate);
}
public MappingContext(
ModelConfiguration modelConfiguration,
ConventionsConfiguration conventionsConfiguration,
EdmModel model,
DbModelBuilderVersion modelBuilderVersion = DbModelBuilderVersion.Latest,
AttributeProvider attributeProvider = null)
{
DebugCheck.NotNull(modelConfiguration);
DebugCheck.NotNull(conventionsConfiguration);
DebugCheck.NotNull(model);
_modelConfiguration = modelConfiguration;
_conventionsConfiguration = conventionsConfiguration;
_model = model;
_modelBuilderVersion = modelBuilderVersion;
_attributeProvider = attributeProvider ?? new AttributeProvider();
}
public void Configure_adds_convention()
{
Func<Type, bool> predicate = t => true;
Action<LightweightEntityConfiguration<object>> configurationAction = c => { };
var conventions = new ConventionsConfiguration();
var entities = new EntityConventionOfTypeConfiguration<object>(conventions);
entities
.Where(predicate)
.Configure(configurationAction);
Assert.Equal(36, conventions.Conventions.Count());
var convention = (EntityConventionOfType<object>)conventions.Conventions.Last();
Assert.Equal(2, convention.Predicates.Count());
Assert.Same(predicate, convention.Predicates.Last());
Assert.Same(configurationAction, convention.EntityConfigurationAction);
}
public void Configure_adds_convention()
{
Func<PropertyInfo, bool> predicate = p => true;
Action<LightweightPropertyConfiguration> configurationAction = c => { };
var conventions = new ConventionsConfiguration();
var properties = new PropertyConventionConfiguration(conventions);
properties
.Where(predicate)
.Configure(configurationAction);
Assert.Equal(36, conventions.Conventions.Count());
var convention = (PropertyConvention)conventions.Conventions.Last();
Assert.Equal(1, convention.Predicates.Count());
Assert.Same(predicate, convention.Predicates.Single());
Assert.Same(configurationAction, convention.PropertyConfigurationAction);
}
public void Configure_adds_convention()
{
Func<Type, bool> predicate = t => true;
Action<ConventionTypeConfiguration> configurationAction = c => { };
var conventions = new ConventionsConfiguration();
var entities = new TypeConventionConfiguration(conventions);
entities
.Where(predicate)
.Configure(configurationAction);
Assert.Equal(16, conventions.ConfigurationConventions.Count());
var convention = (TypeConvention)conventions.ConfigurationConventions.Last();
Assert.Equal(1, convention.Predicates.Count());
Assert.Same(predicate, convention.Predicates.Single());
Assert.Same(configurationAction, convention.EntityConfigurationAction);
}
public void Configure_adds_convention()
{
Func <Type, bool> predicate = t => true;
Action <ConventionTypeConfiguration <object> > configurationAction = c => { };
var conventions = new ConventionsConfiguration();
var entities = new TypeConventionConfiguration <object>(conventions);
entities
.Where(predicate)
.Configure(configurationAction);
Assert.Equal(16, conventions.ConfigurationConventions.Count());
var convention = (TypeConvention <object>)conventions.ConfigurationConventions.Last();
Assert.Equal(2, convention.Predicates.Count());
Assert.Same(predicate, convention.Predicates.Last());
Assert.Same(configurationAction, convention.EntityConfigurationAction);
}
public void Cloning_the_conventions_configuration_clones_the_list_of_conventions_but_not_the_conventions_themselves()
{
var convention1 = new Mock <IConvention>().Object;
var conventions = new ConventionsConfiguration(
new List <IConvention>
{
convention1
});
Assert.Same(conventions.Conventions, conventions.Conventions);
var clone = conventions.Clone();
var convention2 = new Mock <IConvention>().Object;
conventions.Add(convention2);
Assert.NotSame(conventions.Conventions, clone.Conventions);
Assert.True(clone.Conventions.Contains(convention1));
Assert.False(clone.Conventions.Contains(convention2));
}
public void Configure_adds_convention()
{
Func<Type, bool> predicate = t => true;
Func<Type, object> capturingPredicate = t => null;
Action<LightweightEntityConfiguration, object> configurationAction = (c, o) => { };
var conventions = new ConventionsConfiguration();
var entities = new EntityConventionConfiguration(conventions);
entities
.Where(predicate)
.Having(capturingPredicate)
.Configure(configurationAction);
Assert.Equal(36, conventions.Conventions.Count());
var convention = (EntityConventionWithHaving<object>)conventions.Conventions.Last();
Assert.Equal(1, convention.Predicates.Count());
Assert.Same(predicate, convention.Predicates.Single());
Assert.Same(capturingPredicate, convention.CapturingPredicate);
Assert.Same(configurationAction, convention.EntityConfigurationAction);
}
public void Configure_adds_convention()
{
Func<PropertyInfo, bool> predicate = p => true;
Func<PropertyInfo, object> capturingPredicate = p => null;
Action<ConventionPrimitivePropertyConfiguration, object> configurationAction = (c, o) => { };
var conventions = new ConventionsConfiguration();
var properties = new PropertyConventionConfiguration(conventions);
properties
.Where(predicate)
.Having(capturingPredicate)
.Configure(configurationAction);
Assert.Equal(16, conventions.ConfigurationConventions.Count());
var convention = (PropertyConventionWithHaving<object>)conventions.ConfigurationConventions.Last();
Assert.Equal(1, convention.Predicates.Count());
Assert.Same(predicate, convention.Predicates.Single());
Assert.Same(capturingPredicate, convention.CapturingPredicate);
Assert.Same(configurationAction, convention.PropertyConfigurationAction);
}
public void Configure_adds_convention()
{
Func <Type, bool> predicate = t => true;
Func <Type, object> capturingPredicate = t => null;
Action <ConventionTypeConfiguration <object>, object> configurationAction = (c, o) => { };
var conventions = new ConventionsConfiguration();
var entities = new TypeConventionConfiguration <object>(conventions);
entities
.Where(predicate)
.Having(capturingPredicate)
.Configure(configurationAction);
Assert.Equal(16, conventions.ConfigurationConventions.Count());
var convention = (TypeConventionWithHaving <object, object>)conventions.ConfigurationConventions.Last();
Assert.Equal(2, convention.Predicates.Count());
Assert.Same(predicate, convention.Predicates.Last());
Assert.Same(capturingPredicate, convention.CapturingPredicate);
Assert.Same(configurationAction, convention.EntityConfigurationAction);
}
public void Configure_adds_convention()
{
Func <PropertyInfo, bool> predicate = p => true;
Func <PropertyInfo, object> capturingPredicate = p => null;
Action <LightweightPropertyConfiguration, object> configurationAction = (c, o) => { };
var conventions = new ConventionsConfiguration();
var properties = new PropertyConventionConfiguration(conventions);
properties
.Where(predicate)
.Having(capturingPredicate)
.Configure(configurationAction);
Assert.Equal(36, conventions.Conventions.Count());
var convention = (PropertyConventionWithHaving <object>)conventions.Conventions.Last();
Assert.Equal(1, convention.Predicates.Count());
Assert.Same(predicate, convention.Predicates.Single());
Assert.Same(capturingPredicate, convention.CapturingPredicate);
Assert.Same(configurationAction, convention.PropertyConfigurationAction);
}
public void ApplyModelConfiguration_should_run_model_configuration_conventions()
{
var mockConvention = new Mock<IConfigurationConvention>();
var conventionsConfiguration = new ConventionsConfiguration(new[] { mockConvention.Object });
var modelConfiguration = new ModelConfiguration();
conventionsConfiguration.ApplyModelConfiguration(modelConfiguration);
mockConvention.Verify(c => c.Apply(modelConfiguration), Times.Once());
}
public void Having_configures_capturing_predicate()
{
var conventions = new ConventionsConfiguration();
var properties = new PropertyConventionConfiguration(conventions);
Func<PropertyInfo, bool> predicate = p => true;
Func<PropertyInfo, object> capturingPredicate = p => null;
var config = properties
.Where(predicate)
.Having(capturingPredicate);
Assert.NotNull(config);
Assert.Same(conventions, config.ConventionsConfiguration);
Assert.Equal(1, config.Predicates.Count());
Assert.Same(predicate, config.Predicates.Single());
Assert.Same(capturingPredicate, config.CapturingPredicate);
}
public void ApplyPropertyTypeConfiguration_should_run_property_type_configuration_conventions()
{
var mockConvention1 = new Mock<IConfigurationConvention<PropertyInfo, ComplexTypeConfiguration>>();
var mockConvention2 = new Mock<IConfigurationConvention<PropertyInfo, StructuralTypeConfiguration>>();
var conventionsConfiguration = new ConventionsConfiguration(
new IConvention[] { mockConvention1.Object, mockConvention2.Object });
var complexTypeConfiguration = new Func<ComplexTypeConfiguration>(() => new ComplexTypeConfiguration(typeof(object)));
var mockPropertyInfo = new MockPropertyInfo();
conventionsConfiguration.ApplyPropertyTypeConfiguration(mockPropertyInfo, complexTypeConfiguration);
mockConvention1.Verify(c => c.Apply(mockPropertyInfo, complexTypeConfiguration), Times.AtMostOnce());
mockConvention2.Verify(c => c.Apply(mockPropertyInfo, complexTypeConfiguration), Times.AtMostOnce());
}
public void ApplyTypeConfiguration_should_run_type_configuration_conventions()
{
var mockConvention1 = new Mock<IConfigurationConvention<Type, EntityTypeConfiguration>>();
var mockConvention2 = new Mock<IConfigurationConvention<Type, StructuralTypeConfiguration>>();
var conventionsConfiguration = new ConventionsConfiguration(
new IConvention[] { mockConvention1.Object, mockConvention2.Object });
var entityTypeConfiguration = new Func<EntityTypeConfiguration>(() => new EntityTypeConfiguration(typeof(object)));
conventionsConfiguration.ApplyTypeConfiguration(typeof(object), entityTypeConfiguration);
mockConvention1.Verify(c => c.Apply(typeof(object), entityTypeConfiguration), Times.AtMostOnce());
mockConvention2.Verify(c => c.Apply(typeof(object), entityTypeConfiguration), Times.AtMostOnce());
}
public void ApplyPropertyConfiguration_should_run_property_configuration_conventions()
{
var mockConvention = new Mock<IConfigurationConvention<PropertyInfo, StringPropertyConfiguration>>();
var conventionsConfiguration = new ConventionsConfiguration(new[] { mockConvention.Object });
var mockPropertyInfo = new MockPropertyInfo(typeof(string), "S");
conventionsConfiguration.ApplyPropertyConfiguration(mockPropertyInfo, () => new StringPropertyConfiguration());
mockConvention.Verify(c => c.Apply(mockPropertyInfo, It.IsAny<Func<StringPropertyConfiguration>>()), Times.AtMostOnce());
}
public void ApplyPropertyConfiguration_should_run_navigation_property_configuration_conventions()
{
var mockConvention1 = new Mock<IConfigurationConvention<PropertyInfo, PropertyConfiguration>>();
var mockConvention2 = new Mock<IConfigurationConvention<PropertyInfo, NavigationPropertyConfiguration>>();
var conventionsConfiguration = new ConventionsConfiguration(
new IConvention[] { mockConvention1.Object, mockConvention2.Object });
var mockPropertyInfo = new MockPropertyInfo(typeof(object), "N");
conventionsConfiguration.ApplyPropertyConfiguration(
mockPropertyInfo,
() => new NavigationPropertyConfiguration(mockPropertyInfo));
mockConvention1.Verify(c => c.Apply(mockPropertyInfo, It.IsAny<Func<PropertyConfiguration>>()), Times.AtMostOnce());
mockConvention2.Verify(c => c.Apply(mockPropertyInfo, It.IsAny<Func<NavigationPropertyConfiguration>>()), Times.AtMostOnce());
}
public void ApplyPropertyConfiguration_should_run_property_model_conventions()
{
var mockConvention = new Mock<IConfigurationConvention<PropertyInfo, ModelConfiguration>>();
var conventionsConfiguration = new ConventionsConfiguration(
new IConvention[] { mockConvention.Object });
var mockPropertyInfo = new MockPropertyInfo(typeof(object), "N");
var modelConfiguration = new ModelConfiguration();
conventionsConfiguration.ApplyPropertyConfiguration(mockPropertyInfo, modelConfiguration);
mockConvention.Verify(c => c.Apply(mockPropertyInfo, It.IsAny<Func<ModelConfiguration>>()), Times.AtMostOnce());
}
public void ApplyPropertyConfiguration_should_run_compatible_property_configuration_conventions()
{
var mockConvention1 = new Mock<IConfigurationConvention<PropertyInfo, StringPropertyConfiguration>>();
var mockConvention2 = new Mock<IConfigurationConvention<PropertyInfo, PropertyConfiguration>>();
var mockConvention3 = new Mock<IConfigurationConvention<PropertyInfo, NavigationPropertyConfiguration>>();
var conventionsConfiguration = new ConventionsConfiguration(
new IConvention[] { mockConvention1.Object, mockConvention2.Object, mockConvention3.Object });
var mockPropertyInfo = new MockPropertyInfo(typeof(string), "S");
conventionsConfiguration.ApplyPropertyConfiguration(mockPropertyInfo, () => new StringPropertyConfiguration());
mockConvention1.Verify(c => c.Apply(mockPropertyInfo, It.IsAny<Func<StringPropertyConfiguration>>()), Times.AtMostOnce());
mockConvention2.Verify(c => c.Apply(mockPropertyInfo, It.IsAny<Func<PropertyConfiguration>>()), Times.AtMostOnce());
mockConvention3.Verify(c => c.Apply(mockPropertyInfo, It.IsAny<Func<NavigationPropertyConfiguration>>()), Times.Never());
}
public void ApplyModelConfiguration_should_run_type_model_configuration_conventions()
{
var mockConvention = new Mock<IConfigurationConvention<Type, ModelConfiguration>>();
var conventionsConfiguration = new ConventionsConfiguration(new[] { mockConvention.Object });
var modelConfiguration = new ModelConfiguration();
conventionsConfiguration.ApplyModelConfiguration(typeof(object), modelConfiguration);
mockConvention.Verify(c => c.Apply(typeof(object), It.IsAny<Func<ModelConfiguration>>()), Times.AtMostOnce());
}
public void ApplyDatabase_should_run_targeted_model_conventions()
{
var database = new DbDatabaseMetadata().Initialize();
var table = database.AddTable("T");
var mockConvention = new Mock<IDbConvention<DbTableMetadata>>();
var conventionsConfiguration = new ConventionsConfiguration(
new IConvention[]
{
mockConvention.Object
});
conventionsConfiguration.ApplyDatabase(database);
mockConvention.Verify(c => c.Apply(table, database), Times.AtMostOnce());
}
public void ApplyModel_should_run_targeted_model_conventions()
{
var model = new EdmModel().Initialize();
var entityType = model.AddEntityType("E");
var mockConvention = new Mock<IEdmConvention<EdmEntityType>>();
var conventionsConfiguration = new ConventionsConfiguration(
new IConvention[]
{
mockConvention.Object
});
conventionsConfiguration.ApplyModel(model);
mockConvention.Verify(c => c.Apply(entityType, model), Times.AtMostOnce());
}
