public void Configuration_should_return_internal_configuration() { var complexTypeConfiguration = new ComplexTypeConfiguration<object>(); Assert.NotNull(complexTypeConfiguration.Configuration); Assert.Equal(typeof(ComplexTypeConfiguration), complexTypeConfiguration.Configuration.GetType()); }
public void Configure_should_set_configuration() { var complexType = new ComplexType("C"); var complexTypeConfiguration = new ComplexTypeConfiguration(typeof(object)); complexTypeConfiguration.Configure(complexType); Assert.Same(complexTypeConfiguration, complexType.GetConfiguration()); }
public void Ignore_configures_complex_type_properties() { var type = typeof(LocalEntityType); var innerConfig = new ComplexTypeConfiguration(type); var config = new ConventionTypeConfiguration<LocalEntityType>(type, () => innerConfig, new ModelConfiguration()); config.Ignore(t => t.Property1); Assert.Equal(1, innerConfig.IgnoredProperties.Count()); Assert.True(innerConfig.IgnoredProperties.Any(p => p.Name == "Property1")); }
public void Configure_should_throw_when_property_not_found() { var complexType = new ComplexType("C"); var complexTypeConfiguration = new ComplexTypeConfiguration(typeof(object)); var mockPropertyConfiguration = new Mock<PrimitivePropertyConfiguration>(); complexTypeConfiguration.Property(new PropertyPath(new MockPropertyInfo()), () => mockPropertyConfiguration.Object); Assert.Equal( Strings.PropertyNotFound(("P"), "C"), Assert.Throws<InvalidOperationException>(() => complexTypeConfiguration.Configure(complexType)).Message); }
public void Configure_should_configure_properties() { var complexType = new ComplexType("C"); var property1 = EdmProperty.Primitive("P", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)); complexType.AddMember(property1); var property = property1; var complexTypeConfiguration = new ComplexTypeConfiguration(typeof(object)); var mockPropertyConfiguration = new Mock<PrimitivePropertyConfiguration>(); var mockPropertyInfo = new MockPropertyInfo(); complexTypeConfiguration.Property(new PropertyPath(mockPropertyInfo), () => mockPropertyConfiguration.Object); property.SetClrPropertyInfo(mockPropertyInfo); complexTypeConfiguration.Configure(complexType); mockPropertyConfiguration.Verify(p => p.Configure(property)); }
public void AddConfigurationTypesToModel_adds_complextypeconfigurations_into_model() { var complexTypeConfiguration = new ComplexTypeConfiguration(typeof(Random)); var filter = new Mock<ConfigurationTypeFilter>(); filter.Setup(f => f.IsEntityTypeConfiguration(It.IsAny<Type>())).Returns(false); filter.Setup(f => f.IsComplexTypeConfiguration(It.IsAny<Type>())).Returns(true); var activator = new Mock<ConfigurationTypeActivator>(); activator.Setup(a => a.Activate<ComplexTypeConfiguration>(It.IsAny<Type>())) .Returns(complexTypeConfiguration); var finder = new ConfigurationTypesFinder(activator.Object, filter.Object); var modelConfiguration = new ModelConfiguration(); finder.AddConfigurationTypesToModel(new[] { typeof(Object) }, modelConfiguration); Assert.Same(complexTypeConfiguration, modelConfiguration.ComplexType(typeof(Random))); }
public void Invokes_action_with_value_when_not_null() { var actionInvoked = false; object capturedValue = null; var value = new object(); var convention = new TypeConventionWithHaving<object, object>( Enumerable.Empty<Func<Type, bool>>(), t => value, (c, v) => { actionInvoked = true; capturedValue = v; }); var type = typeof(object); var configuration = new ComplexTypeConfiguration(type); convention.Apply(type, () => configuration, new ModelConfiguration()); Assert.True(actionInvoked); Assert.Same(value, capturedValue); }
public void Invokes_action_when_all_predicates_true() { var actionInvoked = false; var convention = new TypeConvention( new Func<Type, bool>[] { t => true, t => true }, c => actionInvoked = true); var type = new MockType(); var configuration = new ComplexTypeConfiguration(type); convention.Apply(type, () => configuration, new ModelConfiguration()); Assert.True(actionInvoked); }
internal virtual void Add(ComplexTypeConfiguration complexTypeConfiguration) { //Contract.Requires(complexTypeConfiguration != null); if ((_entityConfigurations.ContainsKey(complexTypeConfiguration.ClrType) || _complexTypeConfigurations.ContainsKey(complexTypeConfiguration.ClrType))) { throw Error.DuplicateStructuralTypeConfiguration(complexTypeConfiguration.ClrType); } _complexTypeConfigurations.Add(complexTypeConfiguration.ClrType, complexTypeConfiguration); }
private ComplexTypeConfiguration(ComplexTypeConfiguration source) : base((StructuralTypeConfiguration)source) { }
public void Property_returns_configuration_for_complex_type_properties() { var type = typeof(AType); var innerConfig = new ComplexTypeConfiguration(type); var config = new ConventionTypeConfiguration(type, () => innerConfig, new ModelConfiguration()); config.IsComplexType(); var result = config.Property("Property5"); Assert.NotNull(result); Assert.NotNull(result.ClrPropertyInfo); Assert.Equal("Property5", result.ClrPropertyInfo.Name); Assert.Equal(typeof(decimal), result.ClrPropertyInfo.PropertyType); Assert.NotNull(result.Configuration); Assert.IsType<Properties.Primitive.DecimalPropertyConfiguration>(result.Configuration()); }
public virtual ComplexTypeConfiguration ComplexType(Type complexType) { //Contract.Requires(complexType != null); if (_entityConfigurations.ContainsKey(complexType)) { throw Error.ComplexTypeConfigurationMismatch(complexType.FullName); } ComplexTypeConfiguration complexTypeConfiguration; if (!_complexTypeConfigurations.TryGetValue(complexType, out complexTypeConfiguration)) { _complexTypeConfigurations.Add( complexType, complexTypeConfiguration = new ComplexTypeConfiguration(complexType)); } return complexTypeConfiguration; }
public void Does_not_invoke_action_when_predicate_false_but_same_type() { var actionInvoked = false; var convention = new TypeConvention<LocalType1>( new Func<Type, bool>[] { t => false }, c => actionInvoked = true); var type = typeof(LocalType1); var configuration = new ComplexTypeConfiguration(type); convention.Apply(type, () => configuration, new ModelConfiguration()); Assert.False(actionInvoked); }
private ComplexTypeConfiguration(ComplexTypeConfiguration source) : base(source) { }
public void Does_not_invoke_action_when_no_predicates_and_different_type() { var actionInvoked = false; var convention = new TypeConvention<LocalType1>( Enumerable.Empty<Func<Type, bool>>(), c => actionInvoked = true); var type = typeof(object); var configuration = new ComplexTypeConfiguration(type); convention.Apply(type, () => configuration, new ModelConfiguration()); Assert.False(actionInvoked); }
public void Does_not_invoke_action_and_short_circuts_when_different_type() { var predicateInvoked = false; var actionInvoked = false; var convention = new TypeConvention<LocalType1>( new Func<Type, bool>[] { t => predicateInvoked = true }, c => actionInvoked = true); var type = typeof(object); var configuration = new ComplexTypeConfiguration(type); convention.Apply(type, () => configuration, new ModelConfiguration()); Assert.False(predicateInvoked); Assert.False(actionInvoked); }
public void Does_not_invoke_action_when_value_null() { var actionInvoked = false; var convention = new TypeConventionWithHaving<object, object>( Enumerable.Empty<Func<Type, bool>>(), t => null, (c, v) => actionInvoked = true); var type = typeof(object); var configuration = new ComplexTypeConfiguration(type); convention.Apply(type, () => configuration, new ModelConfiguration()); Assert.False(actionInvoked); }
public void Invokes_action_when_no_predicates_and_derived_type() { var actionInvoked = false; var convention = new TypeConvention<LocalType1>( Enumerable.Empty<Func<Type, bool>>(), c => actionInvoked = true); var type = typeof(LocalType2); var configuration = new ComplexTypeConfiguration(type); convention.Apply(type, () => configuration, new ModelConfiguration()); Assert.True(actionInvoked); }
public void Does_not_invoke_action_when_last_predicate_false() { var actionInvoked = false; var convention = new TypeConvention( new Func<Type, bool>[] { t => true, t => false }, c => actionInvoked = true); var type = new MockType(); var configuration = new ComplexTypeConfiguration(type); convention.Apply(type, () => configuration, new ModelConfiguration()); Assert.False(actionInvoked); }
public virtual ComplexTypeConfiguration ComplexType(Type complexType) { Check.NotNull(complexType, "complexType"); if (_entityConfigurations.ContainsKey(complexType)) { throw Error.ComplexTypeConfigurationMismatch(complexType.FullName); } ComplexTypeConfiguration complexTypeConfiguration; if (!_complexTypeConfigurations.TryGetValue(complexType, out complexTypeConfiguration)) { _complexTypeConfigurations.Add( complexType, complexTypeConfiguration = new ComplexTypeConfiguration(complexType)); } return complexTypeConfiguration; }
internal virtual void Add(ComplexTypeConfiguration complexTypeConfiguration) { DebugCheck.NotNull(complexTypeConfiguration); if ((_entityConfigurations.ContainsKey(complexTypeConfiguration.ClrType) || _complexTypeConfigurations.ContainsKey(complexTypeConfiguration.ClrType))) { throw Error.DuplicateStructuralTypeConfiguration(complexTypeConfiguration.ClrType); } _complexTypeConfigurations.Add(complexTypeConfiguration.ClrType, complexTypeConfiguration); }
public void Ignore_configures_complex_type_property() { var type = new MockType() .Property<int>("Property1"); var innerConfig = new ComplexTypeConfiguration(type); var config = new ConventionTypeConfiguration(type, () => innerConfig, new ModelConfiguration()); config.IsComplexType(); config.Ignore("Property1"); Assert.Equal(1, innerConfig.IgnoredProperties.Count()); Assert.True(innerConfig.IgnoredProperties.Any(p => p.Name == "Property1")); }
private ComplexTypeConfiguration(ComplexTypeConfiguration source) : base(source) { }