private PropertyConventionConfiguration( ConventionsConfiguration conventionsConfiguration, IEnumerable <Func <PropertyInfo, bool> > predicates) { this._conventionsConfiguration = conventionsConfiguration; this._predicates = predicates; }
private TypeConventionConfiguration( ConventionsConfiguration conventionsConfiguration, IEnumerable <Func <Type, bool> > predicates) { this._conventionsConfiguration = conventionsConfiguration; this._predicates = predicates; }
private ConventionsConfiguration(ConventionsConfiguration source) { this._configurationConventions.AddRange((IEnumerable <IConvention>)source._configurationConventions); this._conceptualModelConventions.AddRange((IEnumerable <IConvention>)source._conceptualModelConventions); this._conceptualToStoreMappingConventions.AddRange((IEnumerable <IConvention>)source._conceptualToStoreMappingConventions); this._storeModelConventions.AddRange((IEnumerable <IConvention>)source._storeModelConventions); }
public void AddBefore <TExistingConvention>(IConvention newConvention) where TExistingConvention : IConvention { Check.NotNull <IConvention>(newConvention, nameof(newConvention)); bool flag = true; if (ConventionsTypeFilter.IsConfigurationConvention(newConvention.GetType()) && ConventionsTypeFilter.IsConfigurationConvention(typeof(TExistingConvention))) { flag = false; ConventionsConfiguration.Insert(typeof(TExistingConvention), 0, newConvention, (IList <IConvention>) this._configurationConventions); } if (ConventionsTypeFilter.IsConceptualModelConvention(newConvention.GetType()) && ConventionsTypeFilter.IsConceptualModelConvention(typeof(TExistingConvention))) { flag = false; ConventionsConfiguration.Insert(typeof(TExistingConvention), 0, newConvention, (IList <IConvention>) this._conceptualModelConventions); } if (ConventionsTypeFilter.IsStoreModelConvention(newConvention.GetType()) && ConventionsTypeFilter.IsStoreModelConvention(typeof(TExistingConvention))) { flag = false; ConventionsConfiguration.Insert(typeof(TExistingConvention), 0, newConvention, (IList <IConvention>) this._storeModelConventions); } if (ConventionsTypeFilter.IsConceptualToStoreMappingConvention(newConvention.GetType()) && ConventionsTypeFilter.IsConceptualToStoreMappingConvention(typeof(TExistingConvention))) { flag = false; ConventionsConfiguration.Insert(typeof(TExistingConvention), 0, newConvention, (IList <IConvention>) this._conceptualToStoreMappingConventions); } if (flag) { throw new InvalidOperationException(Strings.ConventionsConfiguration_ConventionTypeMissmatch((object)newConvention.GetType(), (object)typeof(TExistingConvention))); } }
private EntityConventionConfiguration(ConventionsConfiguration conventionsConfiguration, IEnumerable <Func <Type, bool> > predicates) { DebugCheck.NotNull(conventionsConfiguration); DebugCheck.NotNull(predicates); _conventionsConfiguration = conventionsConfiguration; _predicates = predicates; }
private ConventionsConfiguration(ConventionsConfiguration source) { DebugCheck.NotNull(source); _configurationConventions.AddRange(source._configurationConventions); _conceptualModelConventions.AddRange(source._conceptualModelConventions); _conceptualToStoreMappingConventions.AddRange(source._conceptualToStoreMappingConventions); _storeModelConventions.AddRange(source._storeModelConventions); }
internal TypeConventionWithHavingConfiguration( ConventionsConfiguration conventionsConfiguration, IEnumerable <Func <Type, bool> > predicates, Func <Type, T> capturingPredicate) { this._conventionsConfiguration = conventionsConfiguration; this._predicates = predicates; this._capturingPredicate = capturingPredicate; }
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 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 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 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 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 ApplyDatabase_should_run_database_conventions() { var database = new EdmModel(DataSpace.CSpace); 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 properties = new PropertyConventionConfiguration(conventions); var ex = Assert.Throws <ArgumentNullException>( () => properties.Having <object>(null)); Assert.Equal("capturingPredicate", ex.ParamName); }
public void ApplyPropertyConfiguration_should_run_property_configuration_conventions() { var mockConvention = new Mock <IConfigurationConvention <PropertyInfo, Properties.Primitive.StringPropertyConfiguration> >(); var conventionsConfiguration = new ConventionsConfiguration(new[] { mockConvention.Object }); var mockPropertyInfo = new MockPropertyInfo(typeof(string), "S"); conventionsConfiguration.ApplyPropertyConfiguration(mockPropertyInfo, () => new Properties.Primitive.StringPropertyConfiguration()); mockConvention.Verify(c => c.Apply(mockPropertyInfo, It.IsAny <Func <Properties.Primitive.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 ApplyModel_should_run_model_conventions() { var model = new EdmModel(DataSpace.CSpace); 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 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()); }
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()); }
internal TypeConventionWithHavingConfiguration( ConventionsConfiguration conventionsConfiguration, IEnumerable <Func <Type, bool> > predicates, Func <Type, T> capturingPredicate) { DebugCheck.NotNull(conventionsConfiguration); DebugCheck.NotNull(predicates); DebugCheck.NotNull(capturingPredicate); _conventionsConfiguration = conventionsConfiguration; _predicates = predicates; _capturingPredicate = 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()); }
private static void Insert( Type existingConventionType, int offset, IConvention newConvention, IList <IConvention> conventions) { int num = ConventionsConfiguration.IndexOf(existingConventionType, conventions); if (num < 0) { throw Error.ConventionNotFound((object)newConvention.GetType(), (object)existingConventionType); } conventions.Insert(num + offset, newConvention); }
public void ApplyDatabase_should_run_targeted_model_conventions() { var database = new EdmModel(DataSpace.SSpace); 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 ApplyModel_should_run_targeted_model_conventions() { var model = new EdmModel(DataSpace.CSpace); 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 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()); }
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 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 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); }