private void ReportIgnoredMember( string propertyName, TDestination dest, MapMemberTester <TSource, TDestination> memberTester) { object actual = memberTester.GetActualValue(dest); _log($"\t{propertyName} = {FormatValue(actual)}"); }
/// <summary> /// Returns a String which represents the MapTester instance. /// </summary> /// <returns>a String which represents the MapTester instance.</returns> public override string ToString() { try { string[] ignoredProperties = _destProperties.Where(x => MemberShouldBeIgnored(x.Name)).Select(x => x.Name).ToArray(); var sb = new StringBuilder($"\tMapTester.ForMap<{typeof(TSource).Name}, {typeof(TDestination).Name}>()"); foreach (string propertyName in _destProperties.Select(x => x.Name).Where(x => !ignoredProperties.Contains(x))) { if (_memberTesters.ContainsKey(propertyName)) { MapMemberTester <TSource, TDestination> mapMemberTester = _memberTesters[propertyName]; string testDescription = mapMemberTester.TestDescription; if (!string.IsNullOrWhiteSpace(testDescription)) { sb.Append($"\n\t\t.WhereMember(dest => dest.{propertyName}).{testDescription}"); } } } if (ignoredProperties.Length > 0) { sb.Append($"\n\t\t.IgnoringMember{((ignoredProperties.Length > 1) ? "s" : "")}(dest => dest."); sb.Append(string.Join(", dest => dest.", ignoredProperties)); sb.Append(")"); } return(sb.ToString()); } catch { return(GetType().FullName); } }
/// <summary> /// Assert that all defined properties were successfully maped /// from <typeparamref name="TSource"/> to <typeparamref name="TDestination"/>. /// </summary> /// <param name="source">An instance of type <typeparamref name="TDestination"/>.</param> /// <param name="dest">An instance of type <typeparamref name="TDestination"/>.</param> /// <exception cref="ScenarioTestFailureException">if dest properties don't have expected values.</exception> /// <example> /// <code><![CDATA[ /// MapTester /// .ForMap<Foo, Bar>() /// .AssertMappedValues(foo, bar); /// ]]> /// </code> /// </example> public void AssertMappedValues(TSource source, TDestination dest) { string sourceName = typeof(TSource).FullName; string destName = typeof(TDestination).FullName; _log($"Asserting mapping from \n{sourceName} to \n{destName}:"); _destProperties .OrderBy(x => x.Name) .Select(x => x.Name) .TestEach(propertyName => { if (_memberTesters.ContainsKey(propertyName)) { MapMemberTester <TSource, TDestination> memberTester = _memberTesters[propertyName]; if (memberTester.ShouldBeIgnored) { ReportIgnoredMember(propertyName, dest, memberTester); } else { AssertMappedValue(propertyName, source, dest, memberTester); } } else { throw new MapTesterException($"Property \"{propertyName}\" was not tested."); } }); }
/// <summary> /// Specify <typeparamref name="TDestination"/> property to be tested. /// </summary> /// <param name="destExpression">Expression to get property name.</param> /// <returns>New <see cref="MapMemberTester{TSource, TDestination}"/> instance.</returns> /// <example><![CDATA[ /// MapTester.ForMap<Foo, Bar>() /// .WhereMember(dest => dest.Baz).ShouldEqual(src => src.Qux) /// .AssertMappedValues(foo, bar); /// ]]></example> public MapMemberTester <TSource, TDestination> WhereMember(Expression <Func <TDestination, object> > destExpression) { string propertyName = GetPropertyName(destExpression); var memberTester = new MapMemberTester <TSource, TDestination>(this, destExpression.Compile()); SetTesterForProperty(propertyName, memberTester); return(memberTester); }
/// <summary> /// Define <see cref="MapMemberTester{TSource, TDestination}"/> for /// <typeparamref name="TDestination"/> property. /// </summary> /// <remarks> /// This method is usually called by this class's constructor and by the /// "WhereMember" and "IgnoreMember" extension methods. /// </remarks> /// <param name="propertyName">The <typeparamref name="TDestination"/> property name.</param> /// <param name="memberTester">The <see cref="MapMemberTester{TSource, TDestination}"/> to be used /// to test mapping for the property.</param> private void SetTesterForProperty(string propertyName, MapMemberTester <TSource, TDestination> memberTester) { if (_memberTesters.ContainsKey(propertyName)) { _memberTesters[propertyName] = memberTester; } else { _memberTesters.Add(propertyName, memberTester); } }
private void TestMappedProperties(TSource source, TDestination dest) { _destProperties .OrderBy(x => x.Name) .Select(x => x.Name) .TestEach(propertyName => { MapMemberTester <TSource, TDestination> memberTester = (_memberTesters.ContainsKey(propertyName)) ? _memberTesters[propertyName] : null; bool memberShouldBeIgnored = MemberShouldBeIgnored(propertyName, memberTester); if (memberTester == null) { string message = $"Property \"{propertyName}\" was not tested."; if (memberShouldBeIgnored) { _log(message); } else { _untestedProperties.Add(propertyName); throw new MapTesterException(message); } } else { if (memberShouldBeIgnored) { ReportIgnoredMember(propertyName, dest, memberTester); } else { AssertMappedValue(propertyName, source, dest, memberTester); } } }); }
private void AssertMappedValue(string propertyName, TSource source, TDestination dest, MapMemberTester <TSource, TDestination> memberTester) { if (memberTester.CustomTest == null) { object expected = memberTester.GetExpectedValue(source); object actual = memberTester.GetActualValue(dest); if ((actual == null && expected == null) || (actual != null && actual.Equals(expected))) { _log($"\t{propertyName} = {FormatValue(actual)}"); } else { AssertAreEqual(propertyName, expected, actual); } } else { object actual = memberTester.GetActualValue(dest); _log($"\t{propertyName} = {FormatValue(actual)}"); memberTester.CustomTest(source, dest); } }
private bool MemberShouldBeIgnored(string propertyName, MapMemberTester <TSource, TDestination> memberTester) { return((memberTester?.ShouldBeIgnored ?? false) || _ignoringAllOtherMembers || _ignoringMemberNamesStartingWith.Any(x => propertyName.StartsWith(x))); }