Fix #211 - add support for class level validation attributes (#212)

Author: rlvandaveer

CHANGELOG.md

@@ -3,10 +3,13 @@
 ## [Unreleased]
 
 Enhancements:
+* Fix [#211] by [@rlvandaveer] - honor attributes on classes which implement ValidationAttribute
 
 Bugs fixed:
 * Fix [#207](https://github.com/natemcmaster/CommandLineUtils/issues/207) by [@jcaillon]: Option for the case sensitivity of command names
 
+[#211]: https://github.com/natemcmaster/CommandLineUtils/issues/211
+
 ## [v2.3.1]
 
 Bugs fixed:
@@ -315,6 +318,7 @@ Other:
 [@liamdawson]: https://github.com/liamdawson
 [@lvermeulen]: https://github.com/lvermeulen
 [@MadbHatter]: https://github.com/MadbHatter
+[@rlvandaveer]: https://github.com/rlvandaveer
 [@rmcc13]: https://github.com/rmcc13
 [@SeanFeldman]: https://github.com/SeanFeldman
 [@sebastienros]: https://github.com/sebastienros

docs/samples/validation/attributes/Program.cs

@@ -3,8 +3,10 @@
 
 using System;
 using System.ComponentModel.DataAnnotations;
+using System.Linq;
 using McMaster.Extensions.CommandLineUtils;
 
+[MaxSizeOptionRequiresAttachmentValidation()]
 class AttributeProgram
 {
     public static int Main(string[] args) => CommandLineApplication.Execute<AttributeProgram>(args);
@@ -49,6 +51,8 @@ private void OnExecute()
         {
             Console.WriteLine("Max size = " + MaxSize.Value);
         }
+
+        Console.ReadKey();
     }
 }
 
@@ -69,3 +73,19 @@ protected override ValidationResult IsValid(object value, ValidationContext cont
         return ValidationResult.Success;
     }
 }
+
+[AttributeUsage(AttributeTargets.Class)]
+public class MaxSizeOptionRequiresAttachmentValidationAttribute : ValidationAttribute
+{
+    protected override ValidationResult IsValid(object value, ValidationContext context)
+    {
+        if (value is AttributeProgram obj)
+        {
+            if (obj.MaxSize.HasValue && (obj.Attachments == null || obj.Attachments?.Length == 0))
+            {
+                return new ValidationResult("--max-size cannot be used unless --attachments is also specified");
+            }
+        }
+        return ValidationResult.Success;
+    }
+}

src/CommandLineUtils/Conventions/CommandAttributeConvention.cs

@@ -1,17 +1,24 @@
 // Copyright (c) Nate McMaster.
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
+using System;
+using System.ComponentModel.DataAnnotations;
 using System.Reflection;
 using McMaster.Extensions.CommandLineUtils.Abstractions;
+using McMaster.Extensions.CommandLineUtils.Validation;
 
 namespace McMaster.Extensions.CommandLineUtils.Conventions
 {
     /// <summary>
-    /// Adds settings from <see cref="CommandAttribute"/> set
-    /// on the model type for <see cref="CommandLineApplication{TModel}"/>.
+    /// Adds settings from <see cref="CommandAttribute" /> and <see cref="ValidationAttribute"/> set on the model type for <see cref="CommandLineApplication{TModel}" />.
     /// </summary>
+    /// <seealso cref="McMaster.Extensions.CommandLineUtils.Conventions.IConvention" />
     public class CommandAttributeConvention : IConvention
     {
+        /// <summary>
+        /// Apply the convention.
+        /// </summary>
+        /// <param name="context">The context in which the convention is applied.</param>
         /// <inheritdoc />
         public virtual void Apply(ConventionContext context)
         {
@@ -30,6 +37,11 @@ public virtual void Apply(ConventionContext context)
                     Apply(new ConventionContext(subcommand, subcommandAccessor.GetModelType()));
                 }
             }
+
+            foreach (var attr in context.ModelType.GetTypeInfo().GetCustomAttributes<ValidationAttribute>())
+            {
+                context.Application.Validators.Add(new AttributeValidator(attr));
+            }
         }
     }
 }

src/CommandLineUtils/Validation/AttributeValidator.cs

@@ -4,13 +4,14 @@
 using System;
 using System.Collections.Generic;
 using System.ComponentModel.DataAnnotations;
+using McMaster.Extensions.CommandLineUtils.Abstractions;
 
 namespace McMaster.Extensions.CommandLineUtils.Validation
 {
     /// <summary>
-    /// A validator that uses a <see cref="ValidationAttribute"/> to validate a command line option or argument.
+    /// A validator that uses a <see cref="ValidationAttribute"/> to validate a command, command line option, or argument.
     /// </summary>
-    public class AttributeValidator : IValidator
+    public class AttributeValidator : IValidator, ICommandValidator
     {
         private readonly ValidationAttribute _attribute;
 
@@ -74,5 +75,16 @@ private ValidationResult GetValidationResult(List<string> values, ValidationCont
 
             return ValidationResult.Success;
         }
+
+        /// <summary>Checks whether the command is valid using any associated validation attributes.</summary>
+        /// <param name="command">The command line application to validate</param>
+        /// <param name="context">The context under which validation should be performed</param>
+        public ValidationResult GetValidationResult(CommandLineApplication command, ValidationContext context)
+        {
+            var model = (command as IModelAccessor)?.GetModel();
+            return model != null
+                ? _attribute.GetValidationResult(model, context)
+                : _attribute.GetValidationResult(command, context);
+        }
     }
 }

src/CommandLineUtils/releasenotes.props

@@ -1,6 +1,9 @@
 <Project>
   <PropertyGroup>
     <PackageReleaseNotes Condition="'$(VersionPrefix)' == '2.3.2'">
+Enhancement:
+* @rlvandaveer: honor attributes on classes which implement ValidationAttribute
+
 Bugs fixed:
 * @jcaillon: Option for the case sensitivity of command names.
     </PackageReleaseNotes>

test/CommandLineUtils.Tests/AttributeValidatorTests.cs

@@ -57,6 +57,29 @@ public void ItExecutesValidationAttribute(Type attributeType, string validValue,
             Assert.NotEmpty(result.ErrorMessage);
         }
 
+        [Theory]
+        [InlineData(typeof(ClassLevelValidationAttribute), "good", "also good", "bad", "also bad")]
+        public void ItExecutesClassLevelValidationAttribute(Type attributeType, string validProp1Value, string validProp2Value, string invalidProp1Value, string invalidProp2Value)
+        {
+            var attr = (ValidationAttribute)Activator.CreateInstance(attributeType);
+            var app = new CommandLineApplication<ClassLevelValidationApp>();
+            var validator = new AttributeValidator(attr);
+            var factory = new CommandLineValidationContextFactory(app);
+            var context = factory.Create(app);
+
+            app.Model.Arg1 = validProp1Value;
+            app.Model.Arg2 = validProp2Value;
+
+            Assert.Equal(ValidationResult.Success, validator.GetValidationResult(app, context));
+
+            app.Model.Arg1 = invalidProp1Value;
+            app.Model.Arg2 = invalidProp2Value;
+
+            var result = validator.GetValidationResult(app, context);
+            Assert.NotNull(result);
+            Assert.NotEmpty(result.ErrorMessage);
+        }
+
         private class EmailArgumentApp
         {
             [Argument(0), EmailAddress]
@@ -139,5 +162,22 @@ public override bool IsValid(object value)
                 throw new InvalidOperationException();
             }
         }
+
+        private sealed class ClassLevelValidationApp
+        {
+            [Option]
+            public string Arg1 { get; set; }
+            [Option]
+            public string Arg2 { get; set; }
+        }
+
+        [AttributeUsage(AttributeTargets.Class)]
+        private sealed class ClassLevelValidationAttribute : ValidationAttribute
+        {
+            public override bool IsValid(object value)
+                => value is ClassLevelValidationApp app
+                    && app.Arg1.Contains("good")
+                    && app.Arg2.Contains("good");
+        }
     }
 }