Examples with TypeException com.axway.ats.core.validation.exceptions.TypeException used on opensource projects

Example 6 with TypeException

use of com.axway.ats.core.validation.exceptions.TypeException in project ats-framework by Axway.

the class TypeStringFilename method validate.

/**
     * Performs a type-specific validation for the given
     * {@link ValidationType}
     */
@Override
public void validate() throws TypeException {
    // --- proper string string validation ---
    try {
        super.validate();
    } catch (TypeException e) {
        throw new TypeException(ERROR_VALIDATING_FILENAME + e.getMessage(), e.getParameterName(), e);
    }
    // --- proper file name validation
    String filename = (String) this.value;
    File file = new File(filename);
    BaseType typeFile = new TypeFile(file);
    try {
        typeFile.validate();
    } catch (TypeException e) {
        throw new TypeException(ERROR_VALIDATING_FILENAME + e.getMessage(), e.getParameterName());
    }
}

Example 7 with TypeException

use of com.axway.ats.core.validation.exceptions.TypeException in project ats-framework by Axway.

the class ActionMethod method validateArguments.

/**
     * Validate the arguments according to the rules specified in the action
     * using the Parameter annotations
     *
     * @param actionMethod      the implementation of the action
     * @param args              the arguments to validate
     * @throws ActionExecutionException     if exception occurs during arguments validation
     */
protected void validateArguments(Object[] args) throws ActionExecutionException {
    Annotation[][] annotations = method.getParameterAnnotations();
    for (int i = 0; i < annotations.length; i++) {
        Annotation[] paramAnnotations = annotations[i];
        for (Annotation paramAnnotation : paramAnnotations) {
            if (paramAnnotation instanceof Parameter) {
                Parameter paramDescriptionAnnotation = (Parameter) paramAnnotation;
                ValidationType validationType = paramDescriptionAnnotation.validation();
                String[] validationArgs;
                // the name of the array holding the valid constants
                if (validationType == ValidationType.STRING_CONSTANT || validationType == ValidationType.NUMBER_CONSTANT) {
                    try {
                        String arrayName = paramDescriptionAnnotation.args()[0];
                        // get the field and set access level if
                        // necessary
                        Field arrayField = method.getDeclaringClass().getDeclaredField(arrayName);
                        if (!arrayField.isAccessible()) {
                            arrayField.setAccessible(true);
                        }
                        Object arrayValidConstants = arrayField.get(null);
                        // convert the object array to string array
                        String[] arrayValidConstatnsStr = new String[Array.getLength(arrayValidConstants)];
                        for (int j = 0; j < Array.getLength(arrayValidConstants); j++) {
                            arrayValidConstatnsStr[j] = Array.get(arrayValidConstants, j).toString();
                        }
                        validationArgs = arrayValidConstatnsStr;
                    } catch (IndexOutOfBoundsException iobe) {
                        // this is a fatal error
                        throw new ActionExecutionException("You need to specify the name of the array with valid constants in the 'args' field of the Parameter annotation");
                    } catch (Exception e) {
                        // this is a fatal error
                        throw new ActionExecutionException("Could not get array with valid constants - action annotations are incorrect");
                    }
                } else {
                    validationArgs = paramDescriptionAnnotation.args();
                }
                List<BaseType> typeValidators = createBaseTypes(paramDescriptionAnnotation.validation(), paramDescriptionAnnotation.name(), args[i], validationArgs);
                //perform validation
                for (BaseType baseType : typeValidators) {
                    if (baseType != null) {
                        try {
                            baseType.validate();
                        } catch (TypeException e) {
                            throw new InvalidInputArgumentsException("Validation failed while validating argument " + paramDescriptionAnnotation.name() + e.getMessage());
                        }
                    } else {
                        log.warn("Could not perform validation on argument " + paramDescriptionAnnotation.name());
                    }
                }
            }
        }
    }
}