public void MappingThrowsWhenConditionIsNotMetForCollectionOfNestedType()
        {
            IMemberMapper mapper = new MemberMapper();

            mapper.ForSourceType <Source>().ThrowIf(src => !src.Valid, "Source not valid!");

            var source = new SourceNested
            {
                Nested = new Source
                {
                    Foo = "test"
                }
            };

            mapper.Map <IEnumerable <SourceNested>, List <DestinationNested> >(new[] { source });
        }
        public void MappingThrowsWhenConditionIsNotMetForNestedType()
        {
            IMemberMapper mapper = new MemberMapper();

            mapper.ForSourceType <Source>().ThrowIf(src => !src.Valid, "Source not valid!");

            var source = new SourceNested
            {
                Nested = new Source
                {
                    Foo = "test"
                }
            };

            mapper.Map <SourceNested, DestinationNested>(source);
        }
        public void MappingDoesNotThrowWhenConditionIsMetForCollectionOfNestedType()
        {
            IMemberMapper mapper = new MemberMapper();

              mapper.ForSourceType<Source>().ThrowIf(src => !src.Valid, "Source not valid!");

              var source = new SourceNested
              {
            Nested = new Source
            {
              Foo = "test",
              Valid = true
            }
              };

              var result = mapper.Map<IEnumerable<SourceNested>, List<DestinationNested>>(new[] { source });

              Assert.AreEqual("test", result.Single().Nested.Foo);
        }
        public void MappingDoesNotThrowWhenConditionIsMetForCollectionOfNestedType()
        {
            IMemberMapper mapper = new MemberMapper();

            mapper.ForSourceType <Source>().ThrowIf(src => !src.Valid, "Source not valid!");

            var source = new SourceNested
            {
                Nested = new Source
                {
                    Foo   = "test",
                    Valid = true
                }
            };

            var result = mapper.Map <IEnumerable <SourceNested>, List <DestinationNested> >(new[] { source });

            Assert.AreEqual("test", result.Single().Nested.Foo);
        }
        public void MappingDoesNotThrowWhenConditionIsMetForNestedType()
        {
            IMemberMapper mapper = new MemberMapper();

            mapper.ForSourceType <Source>().ThrowIf(src => !src.Valid, "Source not valid!");

            var source = new SourceNested
            {
                Nested = new Source
                {
                    Foo   = "test",
                    Valid = true
                }
            };

            var result = mapper.Map <SourceNested, DestinationNested>(source);

            Assert.AreEqual("test", result.Nested.Foo);
        }
        public void MappingThrowsWhenConditionIsNotMetForNestedType()
        {
            IMemberMapper mapper = new MemberMapper();

              mapper.ForSourceType<Source>().ThrowIf(src => !src.Valid, "Source not valid!");

              var source = new SourceNested
              {
            Nested = new Source
            {
              Foo = "test"
            }
              };

              mapper.Map<SourceNested, DestinationNested>(source);
        }
        public void MappingThrowsWhenConditionIsNotMetForCollectionOfNestedType()
        {
            IMemberMapper mapper = new MemberMapper();

              mapper.ForSourceType<Source>().ThrowIf(src => !src.Valid, "Source not valid!");

              var source = new SourceNested
              {
            Nested = new Source
            {
              Foo = "test"
            }
              };

              mapper.Map<IEnumerable<SourceNested>, List<DestinationNested>>(new[] { source });
        }
        public void MappingDoesNotThrowWhenConditionIsMetForNestedType()
        {
            IMemberMapper mapper = new MemberMapper();

              mapper.ForSourceType<Source>().ThrowIf(src => !src.Valid, "Source not valid!");

              var source = new SourceNested
              {
            Nested = new Source
            {
              Foo = "test",
              Valid = true
            }
              };

              var result = mapper.Map<SourceNested, DestinationNested>(source);

              Assert.AreEqual("test", result.Nested.Foo);
        }