How do you setup unit testable model validation with dependency injection in ASP.NET Core 2 MVC?

Question

I am building an ASP.NET Core 2 MVC application. A lot of the time I need to make use of dependencies to validate user input. I want my validation methods to be unit testable, and I want to be able to inject mocked dependencies into them. This is something I have previously done in MVC5 to great success but cannot work out the ASP.NET Core 2 equivalent.

This is how I would do it in MVC5:

// the view model to be validated
public class MyViewModel {
  public string Username { get; set; }
}

// the model validator that will have dependencies injected into it
public class MyViewModelValidator : ModelValidator
{
  private IUserService users;
  private MyViewModel model;

  public MyViewModelValidator(ModelMetadata metadata, ControllerContext controllerContext, IUserService users)
    : base(metadata, controllerContext)
    {
      this.users = users;
      this.model = base.Metadata.Model as MyViewModel;
    }

  public override IEnumerable<ModelValidationResult> Validate(object container)
  {
      List<ModelValidationResult> errors = new List<ModelValidationResult>();

      if (this.users.CheckExists(this.model.Username))
      {
          errors.Add(new ModelValidationResult() { MemberName = nameof(MyViewModel.Username), Message = "Username is not available" });
      }

      return errors;
  }
}

// this class works out which validator is required for a given model and 
// injects the appropriate dependencies that is resolves using unity in my
// in my case
public class ViewModelValidatorProvider : ModelValidatorProvider
{
  private IUnityContainer container;

  public ViewModelValidatorProvider() => this.container = DependencyResolver.Current.GetService<IUnityContainer>();

  public override IEnumerable<ModelValidator> GetValidators(ModelMetadata metadata, ControllerContext context)
  {
    if (metadata.ModelType == typeof(MyViewModel))
      yield return new MyViewModelValidator(metadata, context, this.container.Resolve<IUserService>());
  }
}

// the provider is hooked up in the app start in Global.asax.cs file
public class MvcApplication : System.Web.HttpApplication
{
  protected void Application_Start()
  {
    ModelValidatorProviders.Providers.Add(new ViewModelValidatorProvider());
  }
}

Now I can just create an instance of the validator with mocked dependencies and away I go! Sadly ASP.NET Core 2 doesn't have the ModelValidator class and everything I have found so far seems to want to inject dependencies via the controller or to resolve them with in an IValidatableObjects Validate() function.

Is it possible to do this in MVC Core?

See if this may be of some use to you https://stackoverflow.com/questions/36109052/inject-service-into-action-filter/36109690#36109690 — Nkosi, May 25 '18 at 14:54

score 1 · Accepted Answer · answered Jun 12 '18 at 12:42

So following the post @Nkosi left in a comment on the question I started down the right path (I think) and ended up implementing a validation system based on type filters.

To start I have a base validator model that we need to implement in our type filters:

    public abstract class BaseViewModelValidator<TModel> : IAsyncActionFilter
    where TModel : class
{
    public async virtual Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
    {
        // get the model to validate
        if (context.ActionArguments["model"] is TModel model)
            await this.ValidateAsync(model, context.ModelState);
        else
            throw new Exception($"View model of type `{context.ActionArguments["model"].GetType()}` found, type of `{typeof(TModel)}` is required.");

        await next();
    }

    public abstract Task ValidateAsync(TModel model, ModelStateDictionary state);        
}

Then, because it is much nicer to use it as a named attribute rather than [TypeFilter(typeof(SomeActionFilter))], I create a TypeFilterAttribute that wraps the implementation of my base validator like this:

public class DemoViewModelValidatorAttribute : TypeFilterAttribute
{
    public DemoViewModelValidatorAttribute() 
        : base(typeof(DemoViewModelValidator))
    {
    }

    internal class DemoViewModelValidator : BaseViewModelValidator<DemoViewModel>
    {
        private readonly ISomeService service;

        // dependencies are injected here (assuming you've registered them in the start up)
        public DemoViewModelValidator(ISomeService service) => this.service = service;

        public async override Task ValidateAsync(DemoViewModel model, ModelStateDictionary state)
        {
            if (await this.service.CheckSomethingAsync(model))
                state.AddModelError(nameof(model.SomeProperty), $"Whoops!!!");
        }
    }
}

You can then unit test your DemoViewModelValidator to your hearts content! Hopefully someone finds this useful!

How do you setup unit testable model validation with dependency injection in ASP.NET Core 2 MVC?

1 Answers1

Linked