Dall'archivio script > ASP.NET Core

Scenari complessi di validazione con FluentValidation su ASP.NET Core

di Andrea TosatoAndrea Tosato, in ASP.NET Core,

Nello scorso script (https://www.aspitalia.com/script/1312/Utilizzare-Framework-FluentValidation-ASP.NET-Core.aspx) ci siamo occupati di FluentValidation con ASP .NET Core e di come validare i dati lato server. FluentValidation permette di implementare anche scenari più complessi, fornendo anche alcuni strumenti utili per il testing dei nostri validatori.

Scrivere un validatore complesso

Partendo dall'esempio mostrato nello script precedente, facciamo evolvere il validatore Person con alcune logiche complesse. Abbiamo quindi inserito delle regole di validazione che accorpano più regole che afferiscono a validazioni di indirizzi mail e numeri telefonici.

public class PersonValidator : AbstractValidator<PersonViewModel>
{
  // .. altro codice qui ..

  // Set Rule
  RuleSet(ValidaMail, () => 
  {
    RuleFor(x => x.EmailAddress).EmailAddress().NotEmpty();
    RuleFor(x => x.PecMail).EmailAddress();
  });
  
  // Set Rule
  RuleSet(ValidaNumeriTelefono, () =>
  {
    RuleFor(x => x.PhoneNumber).NotEmpty().SetValidator(new InternationalPhoneRule());
  });
}

Per richiamare esplicitamente i RuleSet appena dichiarati, è necessario impostare nella CustomizeValidator il set di regole da richiamare in aggiunta alla regola impostata sul ViewModel.

[HttpPost("PersonRule")]
public IActionResult PostRule(
    [CustomizeValidator(RuleSet = Validators.PersonValidator.ValidaNumeriTelefono)]
    [FromBody] PersonViewModel value)
{
    if (ModelState.IsValid)
       return Ok();
    return BadRequest(ModelState);
}

Validatori Personalizzati

In aggiunta è possibile anche specificare dei validatori personalizzati come, ad esempio, InternationalPhoneRule dell'esempio precedente. Un validatore personalizzato quindi ci consente di esprimere logiche complesse sui dati e restituire errori chiari per ogni tipologia di errore. Ecco un esempio:

public class InternationalPhoneRule: PropertyValidator
{
    public InternationalPhoneRule()
        : base("{PropertyName} must contain phone number in format: +IINNN-PPPPPPPP")
    { }
    
    protected override bool IsValid(PropertyValidatorContext context)
    {
        bool isValid = false;
        string phoneNumber = context.PropertyValue as string;

        if (phoneNumber.StartsWith("+"))
        {
            var splitPhone = phoneNumber.Split("-");
            if (splitPhone?.Count() != 2)
                context.MessageFormatter
                  .BuildMessage("{PropertyName} not contains national prefix with separator -");            
            else
                isValid = true;
        }
        else
        {
            context.MessageFormatter
              .BuildMessage("{PropertyName} not contains international prefix with separator +");
        }

        return isValid;
    }
}

Testing

Una funzionalità molto interessante è la possibilità di testare le proprie logiche di validazione campo per campo verificando così gli errori con più precisione.
Nel metodo sottostante, scritto con XUnit, scriviamo un metodo di test che validi il campo Name con il valore null. Il test deve quindi fallire perché abbiamo richiesto l'obbligatorietà del campo e con una stringa di almeno un carattere.

La classe di validazione, attraverso il namespace FluentValidation.TestHelper fornisce una serie di metodi adatti alle classi di testing. In questo caso specifico richiamiamo il metodo ShouldHaveValidationErrorFor che verificherà se la stringa vuota può essere assegnata alla classe. L'esito degli errori di validazione viene inserito in un IEnumerable che ci consente di verificare proprietà per proprietà questo risultato.

[Fact]
public void ValidateName()
{
   var errors = _personValidatior.ShouldHaveValidationErrorFor(p => p.Name, null as string);
   Assert.NotEmpty(errors);

   string errorCode = errors.ToList().First(x => x.PropertyName == "Name").ErrorCode;
   Assert.Equal("NotEmptyValidator", errorCode);
}

Conclusione

Abbiamo visto alcune funzionalità avanzate di FluentValidation come i RuleSet, i validatori personalizzati e la possibilità di eseguire dei test mirati sul codice.
In aggiunta, il framework gestisce gli errori in lingua da specificare in classi apposite.

Il codice esempio che abbiamo descritto in questo script è disponibile al seguente indirizzo: https://github.com/andreatosato/fluentvalidationsample

Commenti

Visualizza/aggiungi commenti

| Condividi su: Twitter, Facebook, LinkedIn
Aggiorna

Per inserire un commento, devi avere un account.

Fai il login e torna a questa pagina, oppure registrati alla nostra community.

Approfondimenti

I più letti di oggi