public void FormatValueFromDirectory_NullButNotNullable_ThrowsMappingException()
        {
            //prepare
            _mappingArguments.PropertyType = typeof(bool);
            var propertyMapping = new BooleanPropertyMapping <BooleanPropertyMappingTest>(_mappingArguments);

            //act
            Executing.This(() => propertyMapping.FormatValueFromDirectory(null, "dn"))
            .Should().Throw <MappingException>();
        }
        public void FormatValueFromDirectory_False_ReturnsSameValue()
        {
            //prepare
            var propertyMapping = new BooleanPropertyMapping <BooleanPropertyMappingTest>(_mappingArguments);

            //act
            var value = propertyMapping.FormatValueFromDirectory(new DirectoryAttribute("name", "FALSE"), "dn");

            //assert
            value.Should().Be.EqualTo(false);
        }
        public void FormatValueToFilter_False_ReturnsFalse()
        {
            //prepare
            var propertyMapping = new BooleanPropertyMapping <BooleanPropertyMappingTest>(_mappingArguments);

            //act
            var value = propertyMapping.FormatValueToFilter(false);

            //assert
            value.Should().Be.EqualTo("FALSE");
        }
        public void FormatValueFromDirectory_Null_ReturnsSameValue()
        {
            //prepare
            _mappingArguments.PropertyType = typeof(bool?);
            var propertyMapping = new BooleanPropertyMapping <BooleanPropertyMappingTest>(_mappingArguments);

            //act
            var value = propertyMapping.FormatValueFromDirectory(null, "dn");

            //assert
            value.Should().Be.Null();
        }
        public void IsEqual_OneNull_ReturnsFalse()
        {
            //prepare
            _mappingArguments.Getter = t => null;
            var propertyMapping = new BooleanPropertyMapping <BooleanPropertyMappingTest>(_mappingArguments);
            DirectoryAttributeModification modification;
            //act
            var value = propertyMapping.IsEqual(this, true, out modification);

            //assert
            value.Should().Be.False();
            modification.Should().Not.Be.Null();
        }
        public void GetDirectoryAttributeModification_False_ReturnsFalse()
        {
            //prepare
            _mappingArguments.Getter = t => false;
            var propertyMapping = new BooleanPropertyMapping <BooleanPropertyMappingTest>(_mappingArguments);

            //act
            var value = propertyMapping.GetDirectoryAttributeModification(this);

            //assert
            value.Name.Should().Be.EqualTo(_mappingArguments.AttributeName);
            value.Operation.Should().Be.EqualTo(DirectoryAttributeOperation.Replace);
            value[0].Should().Be.EqualTo("FALSE");
        }
Exemplo n.º 7
0
        public virtual IPropertyMapping ToPropertyMapping()
        {
            IPropertyMapping mapping;

            var type      = typeof(T);
            var arguments = new PropertyMappingArguments <T>
            {
                PropertyName  = PropertyInfo.Name,
                PropertyType  = PropertyInfo.PropertyType,
                AttributeName = AttributeName ?? PropertyInfo.Name.Replace('_', '-'),
                Getter        = DelegateBuilder.BuildGetter <T>(PropertyInfo),
                Setter        = !type.IsAnonymous()
                                                 ? DelegateBuilder.BuildSetter <T>(PropertyInfo)
                                                 : null,
                IsDistinguishedName = IsDistinguishedName,
                ReadOnly            = IsDistinguishedName ? ReadOnly.Always : ReadOnlyConfiguration.GetValueOrDefault(ReadOnly.Never),
                DirectoryMappings   = null,
                InstanceMappings    = null
            };

            if (PropertyInfo.PropertyType == typeof(DateTime) || PropertyInfo.PropertyType == typeof(DateTime?))
            {
                mapping = new DatePropertyMapping <T>(arguments, DateTimeFormat);
            }
            else if (PropertyInfo.PropertyType.IsEnum || (Nullable.GetUnderlyingType(PropertyInfo.PropertyType) != null &&
                                                          Nullable.GetUnderlyingType(PropertyInfo.PropertyType).IsEnum))
            {
                mapping = new EnumPropertyMapping <T>(arguments, IsEnumStoredAsInt);
            }
            else if (PropertyInfo.PropertyType == typeof(byte[]))
            {
                mapping = new ByteArrayPropertyMapping <T>(arguments);
            }
            else if (PropertyInfo.PropertyType == typeof(Guid) || PropertyInfo.PropertyType == typeof(Guid?))
            {
                mapping = new GuidPropertyMapping <T>(arguments);
            }
            else if (PropertyInfo.PropertyType == typeof(string))
            {
                mapping = new StringPropertyMapping <T>(arguments);
            }
            else if (PropertyInfo.PropertyType == typeof(string[]))
            {
                mapping = new StringArrayPropertyMapping <T>(arguments);
            }
            else if (PropertyInfo.PropertyType == typeof(DateTime[]) || PropertyInfo.PropertyType == typeof(DateTime?[]))
            {
                mapping = new DateArrayPropertyMapping <T>(arguments, DateTimeFormat);
            }
            else if (PropertyInfo.PropertyType == typeof(ICollection <DateTime>) || PropertyInfo.PropertyType == typeof(Collection <DateTime>) ||
                     PropertyInfo.PropertyType == typeof(ICollection <DateTime?>) || PropertyInfo.PropertyType == typeof(Collection <DateTime?>))
            {
                mapping = new DateCollectionPropertyMapping <T>(arguments, DateTimeFormat);
            }
            else if (PropertyInfo.PropertyType == typeof(Collection <string>) || PropertyInfo.PropertyType == typeof(ICollection <string>))
            {
                mapping = new StringCollectionPropertyMapping <T>(arguments);
            }
            else if (PropertyInfo.PropertyType == typeof(Collection <byte[]>) || PropertyInfo.PropertyType == typeof(ICollection <byte[]>))
            {
                mapping = new ByteArrayCollectionPropertyMapping <T>(arguments);
            }
            else if (PropertyInfo.PropertyType == typeof(bool) || PropertyInfo.PropertyType == typeof(bool?))
            {
                mapping = new BooleanPropertyMapping <T>(arguments);
            }
            else if (PropertyInfo.PropertyType == typeof(SecurityIdentifier))
            {
                mapping = new SecurityIdentifierPropertyMapping <T>(arguments);
            }
            else if (PropertyInfo.PropertyType == typeof(SecurityIdentifier[]))
            {
                mapping = new SecurityIdentifierArrayPropertyMapping <T>(arguments);
            }
            else if (PropertyInfo.PropertyType == typeof(ICollection <SecurityIdentifier>) || PropertyInfo.PropertyType == typeof(Collection <SecurityIdentifier>))
            {
                mapping = new SecurityIdentifierCollectionPropertyMapping <T>(arguments);
            }
            else if (PropertyInfo.PropertyType == typeof(X509Certificate2) || PropertyInfo.PropertyType == typeof(X509Certificate))
            {
                mapping = new X509Certificate2PropertyMapping <T>(arguments);
            }
            else if (PropertyInfo.PropertyType == typeof(byte[][]))
            {
                mapping = new ByteArrayArrayPropertyMapping <T>(arguments);
            }
            else if (PropertyInfo.PropertyType == typeof(ICollection <X509Certificate>) || PropertyInfo.PropertyType == typeof(Collection <X509Certificate>) ||
                     PropertyInfo.PropertyType == typeof(ICollection <X509Certificate2>) || PropertyInfo.PropertyType == typeof(Collection <X509Certificate2>))
            {
                mapping = new X509Certificate2CollectionPropertyMapping <T>(arguments);
            }
            else if (PropertyInfo.PropertyType == typeof(X509Certificate[]) || PropertyInfo.PropertyType == typeof(X509Certificate2[]))
            {
                mapping = new X509Certificate2ArrayPropertyMapping <T>(arguments);
            }
            else if (PropertyInfo.PropertyType.IsValueType || (Nullable.GetUnderlyingType(PropertyInfo.PropertyType) != null))
            {
                mapping = new NumericPropertyMapping <T>(arguments);
            }
            else if (typeof(IDirectoryAttributes).IsAssignableFrom(PropertyInfo.PropertyType))
            {
                mapping = new CatchAllPropertyMapping <T>(arguments);
            }
            else
            {
                throw new MappingException(string.Format("Type '{0}' could not be mapped.", PropertyInfo.PropertyType.FullName));
            }

            return(mapping);
        }