Leverage custom validation to discover missing mappings during test-time

Ok, now this approach leverages a multi-phased analysis, best fitted into an unit-test (which may already be present in your solution(s), nevertheless). It´s not a golden gun to magically solve all your issues which may be prevalent, but puts you into a very tight dev-loop which should help clean up things. Period.

The steps involved are

1. enable validation of your AutoMapper-configuration
2. use AutoMapper custom-validation to discover missing type maps
3. add and configure missing type-maps
4. ensure maps are valid
5. adapt changes in enums, or mapping logic (whatever best fits)

   this can be cumbersome and needs extra attention, depending on the issues discovered by this approach

6. rinse and repeat

Examples below use xUnit. Use whatever you might have at hands.

0. starting point

We´re starting with your initial AutoMapper-configuration:

var mapperConfig = new MapperConfiguration(config =>
{
    config.CreateMap<SourceType, DestinationType>();
});

1. enable validation of your AutoMapper-Configuration

Somewhere within your test-suit, ensure you are validating your AutoMapper-configuration:

[Fact]
public void MapperConfigurationIsValid() => mapperConfig.AssertConfigurationIsValid();

2. use AutoMapper custom-validation to discover missing type maps

Now modify your AutoMapper-configuration to this:

mapperConfig = new MapperConfiguration(config =>
            {
                config.CreateMap<SourceType, DestinationType>();

                config.Advanced.Validator(context => {

                    if (!context.Types.DestinationType.IsEnum) return;
                    if (!context.Types.SourceType.IsEnum) return;
                    if (context.TypeMap is not null) return;

                    var message = $"config.CreateMap<{context.Types.SourceType}, {context.Types.DestinationType}>().ConvertUsingEnumMapping(opt => opt.MapByName());";

                    throw new AutoMapperConfigurationException(message);
                });

                config.EnableEnumMappingValidation();
            });

This does a couple of things:

1. look for mappings, that map from an enum to an enum
2. which have no type-map associated to them (that is, they were "generated" by AutoMapper itself and hence are lacking an explicit CreateMap call)

    if (!context.Types.DestinationType.IsEnum) return;
    if (!context.Types.SourceType.IsEnum) return;
    if (context.TypeMap is not null) return;

3. Raise an error, which message is the equivalent of the actual call missing to CreateMap

var message = $"config.CreateMap<{context.Types.SourceType}, {context.Types.DestinationType}>().ConvertUsingEnumMapping(opt => opt.MapByName());";

throw new AutoMapperConfigurationException(message);

3. add and configure missing type-maps

Re-running our previous test, which should fail now, should output something like this:

AutoMapper.AutoMapperConfigurationException : config.CreateMap<Sample.AutoMapper.EnumValidation.Source, Sample.AutoMapper.EnumValidation.Destination>().ConvertUsingEnumMapping(opt => opt.MapByName());

And boom, there you go. The missing type-map configuration call on a silver-plate.

Now copy that line and place it somewhere suitable withing your AutoMapper-configuration.

For this post I´m just putting it below the existing one:

config.CreateMap<SourceType, DestinationType>();
config.CreateMap<Sample.AutoMapper.EnumValidation.Source, Sample.AutoMapper.EnumValidation.Destination>().ConvertUsingEnumMapping(opt => opt.MapByName());

in a real-world scenario, this would be a line for every enum-to-enum mapping that not already has a type-map associated to it within the AutoMapper-configuration. Depending on how you actually configure AutoMapper, this line could need to be slightly adopted to your needs, e.g. for usage in MappingProfiles.

5. adapt changes in enums

Re-run the test from above, which should fail now, too, as there are incompatible enum-values. The output should look something like this:

    AutoMapper.AutoMapperConfigurationException : Missing enum mapping from Sample.AutoMapper.EnumValidation.Source to Sample.AutoMapper.EnumValidation.Destination based on Name
    The following source values are not mapped:
     - B
     - C
     - D
     - Executer
     - A1
     - B2
     - C3

There you go, AutoMapper discovered missing or un-mappable enum-values.

note that we lost automatic handling of differences in casing.

What´s to do now heavily depends on your solution and cannot be covered in a SO-post. So take appropriate actions to mitigate.

6. rinse and repeat

Go back to 3. until all issues are solved.

From then on, you should have a saftey-net in place, that should prevent you from falling into that kind of trap in the future.

However, note that mapping per-name instead of per-value might have a negative impact, performance-wise. That should definetley be taken into account when applying this kind of change to your code-base. But with all those inter-layer-mappings present I would guess a possible bottleneck is in another castle, Mario ;)

A full wrapup of the samples shown in this post can be found in this github-repo

I wrote a validator that would check if the Enums match so I don't have to add those Enum Mappings.

var problematicMapperConfiguration = new MapperConfiguration(config =>
{
    config.Advanced.Validator(EnumMappingValidator.ValidateNamesMatch());
    config.CreateMap<SourceType, DestinationType>();
});

problematicMapperConfiguration.AssertConfigurationIsValid();

With your example it would fail like that:

Expected enum AutoMapperEnumValidation.EarlocTests+Destination to contain enum "D".
Expected enum AutoMapperEnumValidation.EarlocTests+Destination to contain enum "Executer".
Expected enum AutoMapperEnumValidation.EarlocTests+Destination to contain enum "A1".
Expected enum AutoMapperEnumValidation.EarlocTests+Destination to contain enum "B2".
Expected enum AutoMapperEnumValidation.EarlocTests+Destination to contain enum "C3".

The validator is very simple and looks like this:

public class EnumMappingValidator
{
    public static Action<ValidationContext> ValidateNamesMatch()
    {
        return validationContext =>
        {
            var sourceEnumType = GetEnumType(validationContext.Types.SourceType);

            if (sourceEnumType == null)
                return;
            
            var destinationEnumType = GetEnumType(validationContext.Types.DestinationType);

            if (destinationEnumType == null) throw new ArgumentException("Unexpected Enum to Non-Enum Map");

            var sourceEnumNames = sourceEnumType.GetFields().Select(x => x.Name).ToList();
            var destinationEnumNames = destinationEnumType.GetFields().Select(x => x.Name).ToList();

            var errors = new List<string>();

            foreach (var sourceEnumName in sourceEnumNames)
            {
                if (destinationEnumNames.All(x => x.ToLower() != sourceEnumName.ToLower()))
                    errors.Add($"Expected enum {destinationEnumType} to contain enum \"{sourceEnumName}\".");
            }

            if (errors.Any())
                throw new ArgumentException(string.Join(Environment.NewLine, errors));
        };
    }

    private static Type? GetEnumType(Type type)
    {
        if (type.IsEnum) return type;

        var nullableUnderlyingType = Nullable.GetUnderlyingType(type);
        if (nullableUnderlyingType?.IsEnum ?? false) return nullableUnderlyingType;

        return null;
    }
}

Github: https://github.com/matthiaslischka/AutoMapperEnumValidation