private static void WithExceptionHandling <TSource, TDestination>(MapTester <TSource, TDestination> mapTester, Action action)
{
action();
//Remove exception message prettifier that turned out to be not so pretty:
//try
//{
// action();
//}
//catch (MapTesterException ex)
//{
// string message = ExceptionHelper.AddSuggestedFixInfoToMessage(mapTester, ex);
// if (message == ex.Message)
// {
// throw;
// }
// throw new MapTesterException(message);
//}
//catch (AutoMapperConfigurationException ex)
//{
// string message = ExceptionHelper.AddSuggestedFixInfoToMessage(mapTester, ex);
// if (message == ex.Message)
// {
// throw;
// }
// throw new AutoMapperConfigurationException(message);
//}
}
public void AssertMappedValues_should_throw_exception_for_unmapped_dest_property()
{
AssertExceptionThrown
.OfType <MapTesterException>()
.WithMessageContaining("Property \"DestOnly\" was not tested")
.WhenExecuting(() => MapTester.ForMap <Source, Dest>().AssertMappedValues(_source, _dest));
}
public static string AddSuggestedFixInfoToMessage <TSource, TDestination>(
MapTester <TSource, TDestination> mapTester, Exception ex)
{
string message = ex.Message;
try
{
string mapTesterString = mapTester.ToString();
if (mapTesterString.Contains("MapTester.ForMap"))
{
string suggestedCode = mapTesterString
.Replace("MapTester.ForMap", "cfg.CreateMap")
.Replace(".WhereMember(", ".ForMember(")
.Replace(".ShouldEqualValue(", ".UseValue(")
.Replace(".ShouldEqual(", ".MapFrom(")
.Replace(".IsTestedBy((src, dest) => { /* custom test */ })", ".UseValue(() => ???)")
.Replace(".IgnoringMember", ".IgnoreMember");
message = $"{message}\n{new string('_', Console.BufferWidth)}"
+ $"\nThe following code snippet might be useful for making your map match the test:\n"
+ suggestedCode;
}
}
catch
{
}
return(message);
}
/// <summary>
/// Using static Mapper, uses <see cref="Populater"/>/<see cref="RandomValueProvider"/>
/// to create a new <typeparamref name="TSource"/> instance,
/// maps it to a new <typeparamref name="TDestination"/> instance, and
/// calls <see cref="MapTester{TSource, TDestination}.AssertMappedValues(TSource, TDestination)"/>.
/// </summary>
/// <typeparam name="TSource">The type of the source.</typeparam>
/// <typeparam name="TDestination">The type of the destination.</typeparam>
/// <param name="mapTester">The <see cref="MapTester{TSource, TDestination}"/>.</param>
/// <param name="randomValueProvider">(Optional) <see cref="RandomValueProvider"/> override.</param>
/// <returns>The mapped <typeparamref name="TDestination"/> instance.</returns>
public static TDestination AssertAutoMappedRandomValues <TSource, TDestination>(
this MapTester <TSource, TDestination> mapTester, RandomValueProvider randomValueProvider = null)
{
var source = new Populater().CreateAndPopulate <TSource>(randomValueProvider ?? new RandomValueProvider());
return(mapTester.AssertAutoMappedValues(source));
}
/// <summary>
/// Using static Mapper, uses <see cref="RandomValuesHelper"/> to create a new <typeparamref name="TSource"/> instance,
/// maps it to a new <typeparamref name="TDestination"/> instance, and
/// calls <see cref="MapTester{TSource, TDestination}.AssertMappedValues(TSource, TDestination)"/>.
/// </summary>
/// <typeparam name="TSource">The type of the source.</typeparam>
/// <typeparam name="TDestination">The type of the destination.</typeparam>
/// <param name="mapTester">The <see cref="MapTester{TSource, TDestination}"/>.</param>
/// <returns>The mapped <typeparamref name="TDestination"/> instance.</returns>
public static TDestination AssertAutoMappedRandomValues <TSource, TDestination>(
this MapTester <TSource, TDestination> mapTester)
{
var source = new RandomValuesHelper().CreateInstanceWithRandomValues <TSource>();
return(mapTester.AssertAutoMappedValues(source));
}
public void TestInitialize()
{
_source = new Source
{
Name = "Test Name",
Id = 123,
FirstName = "Brian",
LastName = "Schroer",
FullName = "Brian Schroer",
Children = new[] { "Child1", "Child2" }
};
_dest = new Dest
{
Name = "Test Name",
Id = 123,
Children = new[] { "Child1", "Child2" }
};
_mapTester = MapTester.ForMap <Source, Dest>()
//.WithLogging()
.IgnoringMember(dest => dest.DestOnly)
.IgnoringMember(dest => dest.Date)
.IgnoringMember(dest => dest.Children);
}
/// <summary>
/// Using <see cref="IMapper"/> instance,
/// maps <paramref name="source"/> to new <typeparamref name="TDestination"/> instance and
/// calls <see cref="MapTester{TSource, TDestination}.AssertMappedValues(TSource, TDestination)"/>.
/// </summary>
/// <typeparam name="TSource">The type of the source.</typeparam>
/// <typeparam name="TDestination">The type of the destination.</typeparam>
/// <param name="mapTester">The <see cref="MapTester{TSource, TDestination}"/>.</param>
/// <param name="mapper">The <see cref="IMapper"/>.</param>
/// <param name="source">The source object.</param>
/// <returns>The mapped <typeparamref name="TDestination"/> instance.</returns>
public static TDestination AssertAutoMappedValues <TSource, TDestination>(
this MapTester <TSource, TDestination> mapTester, IMapper mapper, TSource source)
{
TDestination mapped = mapper.Map <TSource, TDestination>(source);
mapTester.AssertMappedValues(source, mapped);
return(mapped);
}
private void AssertSourceToDestMapping(Source sourceInstance, Dest destInstance)
{
MapTester.ForMap <Source, Dest>()
.WhereMember(dest => dest.Id).ShouldEqual(src => src.Id)
.WhereMember(dest => dest.Name).ShouldEqual(src => src.FullName)
.WhereMember(dest => dest.Address).ShouldEqualValue("Address")
.AssertMappedValues(sourceInstance, destInstance);
}
public void AssertAutoMappedRandomValues_with_IMapper_should_work()
{
Dest dest = null;
AssertExceptionNotThrown.WhenExecuting(() =>
dest = MapTester.ForMap <Source, Dest>().AssertAutoMappedRandomValues(_mapper));
Assert.IsInstanceOfType(dest, typeof(Dest));
Console.WriteLine(JsonConvert.SerializeObject(dest));
}
public void AssertAutoMappedRandomValues_should_work()
{
Dest dest = null;
AssertExceptionNotThrown.WhenExecuting(() =>
dest = MapTester.ForMap <Source, Dest>().AssertAutoMappedRandomValues());
dest.Should().BeOfType <Dest>();
Console.WriteLine(JsonConvert.SerializeObject(dest));
}
public void AssertAutoMappedValues_should_work()
{
Source source = new RandomValuesHelper().CreateInstanceWithRandomValues <Source>();
Dest dest = null;
AssertExceptionNotThrown.WhenExecuting(() =>
dest = MapTester.ForMap <Source, Dest>().AssertAutoMappedValues(source));
Assert.IsInstanceOfType(dest, typeof(Dest));
Console.WriteLine(JsonConvert.SerializeObject(dest));
}
public void AssertAutoMappedValues_with_IMapper_should_work()
{
Source source = GetRandom.InstanceOf <Source>();
Dest dest = null;
AssertExceptionNotThrown.WhenExecuting(() =>
dest = MapTester.ForMap <Source, Dest>().AssertAutoMappedValues(_mapper, source));
dest.Should().BeOfType <Dest>();
Console.WriteLine(JsonConvert.SerializeObject(dest));
}
public void AssertAutoMappedRandomValues_with_IMapper_and_RandomValueProvider_should_work()
{
Dest dest = null;
AssertExceptionNotThrown.WhenExecuting(() =>
dest = MapTester.ForMap <Source, Dest>().AssertAutoMappedRandomValues(_mapper, this));
dest.Should().BeOfType <Dest>();
dest.Id.Should().Be(_testInt);
Console.WriteLine(JsonConvert.SerializeObject(dest));
}
public void IgnoringAllOtherMembers_should_work_as_expected()
{
var loggedMessages = new List <string>();
MapTester.ForMap <Source, Dest>()
.WithLogging(loggedMessages.Add)
.IgnoringMember(dest => dest.Children)
.IgnoringAllOtherMembers()
.AssertMappedValues(_source, _dest);
Assert.IsNotNull(loggedMessages.SingleOrDefault(x => x == "Property \"DestOnly\" was not tested."));
}
/// <summary>
/// Using <see cref="IMapper"/> instance,
/// maps <paramref name="source"/> to new <typeparamref name="TDestination"/> instance and
/// calls <see cref="MapTester{TSource, TDestination}.AssertMappedValues(TSource, TDestination)"/>.
/// </summary>
/// <typeparam name="TSource">The type of the source.</typeparam>
/// <typeparam name="TDestination">The type of the destination.</typeparam>
/// <param name="mapTester">The <see cref="MapTester{TSource, TDestination}"/>.</param>
/// <param name="mapper">The <see cref="IMapper"/>.</param>
/// <param name="source">The source object.</param>
/// <returns>The mapped <typeparamref name="TDestination"/> instance.</returns>
public static TDestination AssertAutoMappedValues <TSource, TDestination>(
this MapTester <TSource, TDestination> mapTester, IMapper mapper, TSource source)
{
TDestination mapped = default(TDestination);
WithExceptionHandling(mapTester, () =>
{
mapped = mapper.Map <TSource, TDestination>(source);
mapTester.AssertMappedValues(source, mapped);
});
return(mapped);
}
public void IgnoringMember_should_exclude_dest_member_check()
{
var input = new RestaurantEditModel {
Cuisine = CuisineType.Italian, Name = "Test name"
};
var output = new Restaurant {
Cuisine = CuisineType.Italian, Name = "Test name"
};
MapTester.ForMap <RestaurantEditModel, Restaurant>()
.WhereMember(dest => dest.Id).ShouldEqualValue(0)
.AssertMappedValues(input, output);
}
public void Mapping_should_work_from_readonly_properties()
{
var source = new SourceWithReadOnlyProperties();
_dest = new Dest
{
Name = source.Name,
Id = source.Id
};
MapTester.ForMap <SourceWithReadOnlyProperties, Dest>()
.IgnoringMembers(dest => dest.DestOnly, dest => dest.Date, dest => dest.Children)
.AssertMappedValues(source, _dest);
}
public void ToString_should_return_expected_results()
{
const string Stan = "Stan";
ForTest.Scenarios
(
(
MapTester: MapTester.ForMap <Source, Dest>().IgnoringMember(dest => dest.Children).IgnoringMember(dest => dest.DestOnly),
Expected: "MapTester.ForMap<Source, Dest>().IgnoringMembers(dest => dest.Children, dest => dest.DestOnly)"
),
(
MapTester: MapTester.ForMap <Source, Dest>().WhereMember(dest => dest.Name).ShouldEqual(src => src.LastName),
Expected: "MapTester.ForMap<Source, Dest>().WhereMember(dest => dest.Name).ShouldEqual(src => src.LastName)"
),
(
MapTester: MapTester.ForMap <Source, Dest>().WhereMember(dest => dest.Name).ShouldEqual(src => src.FirstName + src.LastName),
Expected: "MapTester.ForMap<Source, Dest>().WhereMember(dest => dest.Name).ShouldEqual(src => (src.FirstName + src.LastName))"
),
(
MapTester: MapTester.ForMap <Source, Dest>().WhereMember(dest => dest.Id).ShouldEqualValue(1).WhereMember(dest => dest.Name).ShouldEqualValue("Stan"),
Expected: "MapTester.ForMap<Source, Dest>().WhereMember(dest => dest.Id).ShouldEqualValue(1).WhereMember(dest => dest.Name).ShouldEqualValue(\"Stan\")"
),
(
MapTester: MapTester.ForMap <Source, Dest>().WhereMember(dest => dest.Name).ShouldEqualValue(null),
Expected: "MapTester.ForMap<Source, Dest>().WhereMember(dest => dest.Name).ShouldEqualValue(null)"
),
(
MapTester: MapTester.ForMap <Source, Dest>().WhereMember(dest => dest.Name).ShouldEqualValue(Stan),
Expected: "MapTester.ForMap<Source, Dest>().WhereMember(dest => dest.Name).ShouldEqualValue(\"Stan\")"
),
(
MapTester: MapTester.ForMap <Source, Dest>().WhereMember(dest => dest.Date).ShouldEqualValue(new DateTime(2018, 1, 15)),
Expected: "MapTester.ForMap<Source, Dest>().WhereMember(dest => dest.Date).ShouldEqualValue(1/15/2018 12:00:00 AM)"
),
(
MapTester: MapTester.ForMap <Source, Dest>().WhereMember(dest => dest.Name).IsTestedBy((src, dest) => { /* custom test */ }),
Expected: "MapTester.ForMap<Source, Dest>().WhereMember(dest => dest.Name).IsTestedBy((src, dest) => { /* custom test */ })"
),
(
MapTester: MapTester.ForMap <Source, Dest>().WhereMember(dest => dest.Name).IsTestedBy(dest => { /* custom test */ }),
Expected: "MapTester.ForMap<Source, Dest>().WhereMember(dest => dest.Name).IsTestedBy(dest => { /* custom test */ })"
)
)
.TestEach(scenario =>
{
string actual = scenario.MapTester.ToString().Replace("\n", "").Replace("\t", "");
Assert.AreEqual(scenario.Expected, actual);
});
}
public void Mapping_should_work_with_matching_properties_with_case_differences()
{
var source = new SourceWithCaseDifferences
{
ID = 123,
NaMe = "Test Name"
};
_dest = new Dest
{
Name = source.NaMe,
Id = source.ID
};
MapTester.ForMap <SourceWithCaseDifferences, Dest>()
.IgnoringMembers(dest => dest.DestOnly, dest => dest.Date, dest => dest.Children)
.AssertMappedValues(source, _dest);
}
public void ShouldBeStringMatchFor_should_work_as_expected()
{
var restaurant = new Restaurant {
Id = 24, Name = "TestName", Cuisine = CuisineType.German
};
var diner = new Diner {
Id = 24, Name = "TestName", Cuisine = FoodType.German
};
var mapTester = MapTester.ForMap <Restaurant, Diner>()
.WhereMember(dest => dest.Cuisine).ShouldBeStringMatchFor(src => src.Cuisine);
AssertExceptionNotThrown.WhenExecuting(() => mapTester.AssertMappedValues(restaurant, diner));
diner.Cuisine = FoodType.Italian;
AssertExceptionThrown
.OfType <MapTesterException>()
.WithMessageContaining("Mapping test failed for property \"Cuisine\". Expected<German>. Actual: <Italian>")
.WhenExecuting(() => mapTester.AssertMappedValues(restaurant, diner));
}
public void HiddenProperty_should_resolve_to_top_most_member()
{
var restaurantEditModel = new RestaurantEditModel {
Cuisine = CuisineType.Italian, Name = "Test name"
};
var restaurantModel = new Restaurant {
Cuisine = CuisineType.Italian, Name = "Test name"
};
var restaurantList = new RestaurantList {
Restaurants = new[] { restaurantModel }
};
var editRestaurantList = new RestaurantEditList {
Restaurants = new[] { restaurantEditModel }
};
MapTester.ForMap <RestaurantList, RestaurantEditList>()
// ignored since the internal constructor of MapTester is what's being tested
.IgnoringMember(dest => dest.Restaurants)
.AssertMappedValues(restaurantList, editRestaurantList);
}
public void MapTester_exception_should_prettify_ScenarioTestFailureException()
{
var source = new Source();
var dummy = new Dummy();
string[] destPropertyNames =
PropertyEnumerator.GetPublicInstanceReadWriteProperties(typeof(Dummy).GetTypeInfo()).Select(x => x.Name).ToArray();
int propertyCount = destPropertyNames.Length;
string message = string.Empty;
try
{
MapTester.ForMap <Source, Dummy>().AssertMappedValues(source, dummy);
}
catch (MapTesterException ex)
{
message = ex.Message;
}
StringAssert.Contains(message, $"{propertyCount} properties tested. 0 passed. {propertyCount} failed.");
StringAssert.DoesNotMatch(message, new Regex("cenario"));
}
/// <summary>
/// Assert that all defined properties were successfully mapped
/// from <typeparamref name="TSource"/> to <typeparamref name="TDestination"/>.
/// </summary>
/// <param name="mapTester">"This" <see cref="MapTester{TSource,TDestination}"/> instance.</param>
/// <param name="source">An instance of type <typeparamref name="TDestination"/>.</param>
/// <param name="dest">An instance of type <typeparamref name="TDestination"/>.</param>
/// <exception cref="MapTesterException">if dest properties don't have expected values.</exception>
/// <example>
/// <code><![CDATA[
/// MapTester
/// .ForMap<Foo, Bar>()
/// .AssertMappedValues(foo, bar);
/// ]]>
/// </code>
/// </example>
public static void AssertMappedValues <TSource, TDestination>(
this MapTester <TSource, TDestination> mapTester, TSource source, TDestination dest)
{
mapTester.AssertMappedValues(source, dest);
}
public void TestInitialize()
{
_source = new RandomValuesHelper().CreateInstanceWithRandomValues <Source>();
_mapTester = MapTester.ForMap <Source, Dest>();
}
/// <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="MapTesterException">if dest properties don't have expected values.</exception>
/// <example>
/// <code><![CDATA[
/// MapTester
/// .ForMap<Foo, Bar>()
/// .AssertMappedValues(foo, bar);
/// ]]>
/// </code>
/// </example>
public static void AssertMappedValues <TSource, TDestination>(
this MapTester <TSource, TDestination> mapTester, TSource source, TDestination dest)
{
WithExceptionHandling(mapTester, () => mapTester.AssertMappedValues(source, dest));
}
