validation: Return structured errors

The end goal is to return more meaningful error data in the HTTP
API rather than just strings:

[
   {
      "value":"memory",
      "default":"9216",
      "request":"6144",
      "reason":"invalid",
      "requires":">= 9216"
   },
   {
      "value":"disk-size",
      "default":"31",
      "request":"19",
      "reason":"invalid",
      "requires":">= 31"
   }
]

instead of

body: "Value '6144' for configuration property 'memory' is invalid, reason: requires memory in MiB >= 9216\n" +
    "Value '19' for configuration property 'disk-size' is invalid, reason: requires disk size in GiB >= 31\n"

See issue crc-org#2973

Author: cfergeau

pkg/crc/config/config.go

@@ -10,7 +10,6 @@ import (
 
 const (
 	configPropDoesntExistMsg = "Configuration property '%s' does not exist"
-	invalidProp              = "Value '%v' for configuration property '%s' is invalid, reason: %s"
 	invalidType              = "Type %T for configuration property '%s' is invalid"
 )
 
@@ -59,32 +58,49 @@ func (c *Config) AddSetting(name string, defValue interface{}, validationFn Vali
 	}
 }
 
+type InvalidPropError struct {
+	value interface{}
+	key   string
+	err   error
+}
+
+func (err *InvalidPropError) Error() string {
+	return fmt.Sprintf("Value '%v' for configuration property '%s' is invalid, reason: %w", err.value, err.key, err.err)
+}
+
+func invalidPropError(value interface{}, key string, err error) error {
+	return &InvalidPropError{
+		value: value,
+		key:   key,
+		err:   err,
+	}
+}
+
 // Set sets the value for a given config key
 func (c *Config) Set(key string, value interface{}) (string, error) {
 	setting, ok := c.settingsByName[key]
 	if !ok {
 		return "", fmt.Errorf(configPropDoesntExistMsg, key)
 	}
 
-	ok, expectedValue := c.settingsByName[key].validationFn(value)
-	if !ok {
-		return "", fmt.Errorf(invalidProp, value, key, expectedValue)
+	err := c.settingsByName[key].validationFn(value)
+	if err != nil {
+		return "", invalidPropError(value, key, err)
 	}
 
 	var castValue interface{}
-	var err error
 	switch setting.defaultValue.(type) {
 	case int:
 		castValue, err = cast.ToIntE(value)
 		if err != nil {
-			return "", fmt.Errorf(invalidProp, value, key, err)
+			return "", invalidPropError(value, key, err)
 		}
 	case string:
 		castValue = cast.ToString(value)
 	case bool:
 		castValue, err = cast.ToBoolE(value)
 		if err != nil {
-			return "", fmt.Errorf(invalidProp, value, key, err)
+			return "", invalidPropError(value, key, err)
 		}
 	case preset.Preset:
 		castValue = cast.ToString(value)

pkg/crc/config/settings.go

@@ -68,7 +68,7 @@ func RegisterSettings(cfg *Config) {
 		return ValidateCPUs(value, GetPreset(cfg))
 	}
 
-	validateMemory := func(value interface{}) (bool, string) {
+	validateMemory := func(value interface{}) error {
 		return ValidateMemory(value, GetPreset(cfg))
 	}
 

pkg/crc/config/types.go

@@ -40,7 +40,7 @@ func (v SettingValue) AsInt() int {
 }
 
 // validationFnType takes the key, value as args and checks if valid
-type ValidationFnType func(interface{}) (bool, string)
+type ValidationFnType func(interface{}) error
 type SetFn func(string, interface{}) string
 
 // RawStorage stores any key-value pair without validation

pkg/crc/config/validations.go

@@ -54,15 +54,15 @@ func ValidateCPUs(value interface{}, preset crcpreset.Preset) (bool, string) {
 }
 
 // ValidateMemory checks if provided memory is valid in the config
-func ValidateMemory(value interface{}, preset crcpreset.Preset) (bool, string) {
+func ValidateMemory(value interface{}, preset crcpreset.Preset) error {
 	v, err := cast.ToIntE(value)
 	if err != nil {
-		return false, fmt.Sprintf("requires integer value in MiB >= %d", constants.GetDefaultMemory(preset))
+		return &validation.IntRangeError{value: v, minimumValue: constants.GetDefaultMemory(preset)}
 	}
 	if err := validation.ValidateMemory(v, preset); err != nil {
-		return false, err.Error()
+		return err
 	}
-	return true, ""
+	return nil
 }
 
 // ValidateBundlePath checks if the provided bundle path is valid

pkg/crc/validation/validation.go

@@ -17,6 +17,15 @@ import (
 	"github.com/pbnjay/memory"
 )
 
+type IntRangeError struct {
+	value        int
+	minimumValue int
+}
+
+func (err *IntRangeError) Error() string {
+	return fmt.Sprintf("requires integer value in MiB >= %d", err.minimumValue)
+}
+
 // ValidateCPUs checks if provided cpus count is valid
 func ValidateCPUs(value int, preset crcpreset.Preset) error {
 	if value < constants.GetDefaultCPUs(preset) {
@@ -28,7 +37,7 @@ func ValidateCPUs(value int, preset crcpreset.Preset) error {
 // ValidateMemory checks if provided Memory count is valid
 func ValidateMemory(value int, preset crcpreset.Preset) error {
 	if value < constants.GetDefaultMemory(preset) {
-		return fmt.Errorf("requires memory in MiB >= %d", constants.GetDefaultMemory(preset))
+		return &IntRangeError{value: value, minimumValue: constants.GetDefaultMemory(preset)}
 	}
 	return ValidateEnoughMemory(value)
 }