Beispiel #1
0
func oneOfMessage(serviceMap RawServiceMap, schema map[string]interface{}, err, nextErr gojsonschema.ResultError) string {
	switch nextErr.Type() {
	case "additional_property_not_allowed":
		property := nextErr.Details()["property"]

		return fmt.Sprintf("contains unsupported option: '%s'", property)
	case "invalid_type":
		if containsTypeError(nextErr) {
			expectedType := addArticle(nextErr.Details()["expected"].(string))

			return fmt.Sprintf("contains %s, which is an invalid type, it should be %s", getValue(serviceMap, nextErr.Context().String()), expectedType)
		}

		validTypes := parseValidTypesFromSchema(schema, err.Context().String())

		validTypesMsg := addArticle(strings.Join(validTypes, " or "))

		return fmt.Sprintf("contains an invalid type, it should be %s", validTypesMsg)
	case "unique":
		contextWithDuplicates := getValue(serviceMap, nextErr.Context().String())

		return fmt.Sprintf("contains non unique items, please remove duplicates from %s", contextWithDuplicates)
	}

	return ""
}
Beispiel #2
0
func unsupportedConfigMessage(key string, nextErr gojsonschema.ResultError) string {
	service := serviceNameFromErrorField(nextErr.Field())

	message := fmt.Sprintf("Unsupported config option for %s service: '%s'", service, key)
	if val, ok := dockerConfigHints[key]; ok {
		message += fmt.Sprintf(" (did you mean '%s'?)", val)
	}

	return message
}
Beispiel #3
0
func invalidTypeMessage(service, key string, err gojsonschema.ResultError) string {
	expectedTypesString := err.Details()["expected"].(string)
	var expectedTypes []string

	if strings.Contains(expectedTypesString, ",") {
		expectedTypes = strings.Split(expectedTypesString[1:len(expectedTypesString)-1], ",")
	} else {
		expectedTypes = []string{expectedTypesString}
	}

	validTypesMsg := addArticle(strings.Join(expectedTypes, " or "))

	return fmt.Sprintf("Service '%s' configuration key '%s' contains an invalid type, it should be %s.", service, key, validTypesMsg)
}
Beispiel #4
0
func getMostSpecificError(errors []gojsonschema.ResultError) gojsonschema.ResultError {
	var mostSpecificError gojsonschema.ResultError

	for _, err := range errors {
		if mostSpecificError == nil {
			mostSpecificError = err
		} else if specificity(err) > specificity(mostSpecificError) {
			mostSpecificError = err
		} else if specificity(err) == specificity(mostSpecificError) {
			// Invalid type errors win in a tie-breaker for most specific field name
			if err.Type() == "invalid_type" && mostSpecificError.Type() != "invalid_type" {
				mostSpecificError = err
			}
		}
	}

	return mostSpecificError
}
Beispiel #5
0
func getDescription(err gojsonschema.ResultError) string {
	if err.Type() == "invalid_type" {
		if expectedType, ok := err.Details()["expected"].(string); ok {
			return fmt.Sprintf("must be a %s", humanReadableType(expectedType))
		}
	}

	return err.Description()
}
Beispiel #6
0
func specificity(err gojsonschema.ResultError) int {
	return len(strings.Split(err.Field(), "."))
}
Beispiel #7
0
func containsTypeError(resultError gojsonschema.ResultError) bool {
	contextSplit := strings.Split(resultError.Context().String(), ".")
	_, err := strconv.Atoi(contextSplit[len(contextSplit)-1])
	return err == nil
}