Examples with InRangeConstraint org.alien4cloud.tosca.model.definitions.constraints.InRangeConstraint used on opensource projects

Example 1 with InRangeConstraint

use of org.alien4cloud.tosca.model.definitions.constraints.InRangeConstraint in project alien4cloud by alien4cloud.

the class ToscaSerializerTest method getConstraintList.

private List<PropertyConstraint> getConstraintList() {
    List<PropertyConstraint> result = new ArrayList<PropertyConstraint>();
    ValidValuesConstraint c1 = new ValidValuesConstraint();
    c1.setValidValues(Lists.newArrayList("one", "two", "tree"));
    result.add(c1);
    GreaterOrEqualConstraint c2 = new GreaterOrEqualConstraint();
    c2.setGreaterOrEqual("2");
    result.add(c2);
    GreaterThanConstraint c3 = new GreaterThanConstraint();
    c3.setGreaterThan("3");
    result.add(c3);
    LessOrEqualConstraint c4 = new LessOrEqualConstraint();
    c4.setLessOrEqual("4");
    result.add(c4);
    LessThanConstraint c5 = new LessThanConstraint();
    c5.setLessThan("5");
    result.add(c5);
    LengthConstraint c6 = new LengthConstraint();
    c6.setLength(6);
    result.add(c6);
    MaxLengthConstraint c7 = new MaxLengthConstraint();
    c7.setMaxLength(7);
    result.add(c7);
    MinLengthConstraint c8 = new MinLengthConstraint();
    c8.setMinLength(8);
    result.add(c8);
    PatternConstraint c9 = new PatternConstraint();
    c9.setPattern("9+");
    result.add(c9);
    EqualConstraint c10 = new EqualConstraint();
    c10.setEqual("10");
    result.add(c10);
    InRangeConstraint c11 = new InRangeConstraint();
    c11.setInRange(Lists.newArrayList("11", "12"));
    result.add(c11);
    return result;
}

Example 2 with InRangeConstraint

use of org.alien4cloud.tosca.model.definitions.constraints.InRangeConstraint in project alien4cloud by alien4cloud.

the class PropertyDefinitionConverter method convert.

public PropertyDefinition convert(FormPropertyDefinition definitionAnnotation) {
    if (definitionAnnotation == null) {
        return null;
    }
    PropertyDefinition propertyDefinition = new PropertyDefinition();
    propertyDefinition.setType(definitionAnnotation.type());
    // FIXME ? can be other than a scalar here ?
    propertyDefinition.setDefault(new ScalarPropertyValue(definitionAnnotation.defaultValue()));
    propertyDefinition.setDescription(definitionAnnotation.description());
    propertyDefinition.setPassword(definitionAnnotation.isPassword());
    propertyDefinition.setRequired(definitionAnnotation.isRequired());
    List<PropertyConstraint> constraints = Lists.newArrayList();
    if (!definitionAnnotation.constraints().equal().isEmpty()) {
        EqualConstraint equalConstraint = new EqualConstraint();
        equalConstraint.setEqual(definitionAnnotation.constraints().equal());
        constraints.add(equalConstraint);
    }
    if (!definitionAnnotation.constraints().greaterOrEqual().isEmpty()) {
        GreaterOrEqualConstraint greaterOrEqualConstraint = new GreaterOrEqualConstraint();
        greaterOrEqualConstraint.setGreaterOrEqual(definitionAnnotation.constraints().greaterOrEqual());
        constraints.add(greaterOrEqualConstraint);
    }
    if (!definitionAnnotation.constraints().greaterThan().isEmpty()) {
        GreaterThanConstraint greaterThanConstraint = new GreaterThanConstraint();
        greaterThanConstraint.setGreaterThan(definitionAnnotation.constraints().greaterThan());
        constraints.add(greaterThanConstraint);
    }
    if (!definitionAnnotation.constraints().inRange().isEmpty()) {
        String inRangeText = definitionAnnotation.constraints().inRange();
        Matcher matcher = IN_RANGE_REGEXP.matcher(inRangeText);
        if (matcher.matches()) {
            InRangeConstraint inRangeConstraint = new InRangeConstraint();
            inRangeConstraint.setRangeMinValue(matcher.group(1).trim());
            inRangeConstraint.setRangeMaxValue(matcher.group(2).trim());
            constraints.add(inRangeConstraint);
        } else {
            throw new FormDescriptorGenerationException("In range constraint definition must be in this format '[ $min - $max ]'");
        }
    }
    if (definitionAnnotation.constraints().length() >= 0) {
        LengthConstraint lengthConstraint = new LengthConstraint();
        lengthConstraint.setLength(definitionAnnotation.constraints().length());
        constraints.add(lengthConstraint);
    }
    if (!definitionAnnotation.constraints().lessOrEqual().isEmpty()) {
        LessOrEqualConstraint lessOrEqualConstraint = new LessOrEqualConstraint();
        lessOrEqualConstraint.setLessOrEqual(definitionAnnotation.constraints().lessOrEqual());
        constraints.add(lessOrEqualConstraint);
    }
    if (!definitionAnnotation.constraints().lessThan().isEmpty()) {
        LessThanConstraint lessThanConstraint = new LessThanConstraint();
        lessThanConstraint.setLessThan(definitionAnnotation.constraints().lessThan());
        constraints.add(lessThanConstraint);
    }
    if (definitionAnnotation.constraints().maxLength() >= 0) {
        MaxLengthConstraint maxLengthConstraint = new MaxLengthConstraint();
        maxLengthConstraint.setMaxLength(definitionAnnotation.constraints().maxLength());
        constraints.add(maxLengthConstraint);
    }
    if (definitionAnnotation.constraints().minLength() >= 0) {
        MinLengthConstraint minLengthConstraint = new MinLengthConstraint();
        minLengthConstraint.setMinLength(definitionAnnotation.constraints().minLength());
        constraints.add(minLengthConstraint);
    }
    if (!definitionAnnotation.constraints().pattern().isEmpty()) {
        PatternConstraint patternConstraint = new PatternConstraint();
        patternConstraint.setPattern(definitionAnnotation.constraints().pattern());
        constraints.add(patternConstraint);
    }
    if (definitionAnnotation.constraints().validValues().length > 0) {
        ValidValuesConstraint validValuesConstraint = new ValidValuesConstraint();
        validValuesConstraint.setValidValues(Lists.newArrayList(definitionAnnotation.constraints().validValues()));
        constraints.add(validValuesConstraint);
    }
    if (!constraints.isEmpty()) {
        propertyDefinition.setConstraints(constraints);
    }
    return propertyDefinition;
}

Example 3 with InRangeConstraint

use of org.alien4cloud.tosca.model.definitions.constraints.InRangeConstraint in project alien4cloud by alien4cloud.

the class ToscaPropertyDefaultValueConstraintsValidatorTest method createInRangeDefinition.

private PropertyDefinition createInRangeDefinition(String propertyType, Comparable minConstraintValue, Comparable maxConstraintValue, String defaultValue) {
    InRangeConstraint constraint = new InRangeConstraint();
    constraint.setInRange(Lists.newArrayList(String.valueOf(minConstraintValue), String.valueOf(maxConstraintValue)));
    return createDefinitions(propertyType, constraint, defaultValue);
}

Example 4 with InRangeConstraint

use of org.alien4cloud.tosca.model.definitions.constraints.InRangeConstraint in project alien4cloud by alien4cloud.

the class ToscaSerializerUtilsTest method testRenderConstraint.

@Test
public void testRenderConstraint() {
    GreaterOrEqualConstraint greaterOrEqualConstraint = new GreaterOrEqualConstraint();
    Assert.assertEquals("greater_or_equal: null", utils.renderConstraint(greaterOrEqualConstraint));
    greaterOrEqualConstraint.setGreaterOrEqual("1");
    Assert.assertEquals("greater_or_equal: 1", utils.renderConstraint(greaterOrEqualConstraint));
    GreaterThanConstraint greaterThanConstraint = new GreaterThanConstraint();
    Assert.assertEquals("greater_than: null", utils.renderConstraint(greaterThanConstraint));
    greaterThanConstraint.setGreaterThan("1");
    Assert.assertEquals("greater_than: 1", utils.renderConstraint(greaterThanConstraint));
    LessOrEqualConstraint lessOrEqualConstraint = new LessOrEqualConstraint();
    Assert.assertEquals("less_or_equal: null", utils.renderConstraint(lessOrEqualConstraint));
    lessOrEqualConstraint.setLessOrEqual("1");
    Assert.assertEquals("less_or_equal: 1", utils.renderConstraint(lessOrEqualConstraint));
    LessThanConstraint lessThanConstraint = new LessThanConstraint();
    Assert.assertEquals("less_than: null", utils.renderConstraint(lessThanConstraint));
    lessThanConstraint.setLessThan("1");
    Assert.assertEquals("less_than: 1", utils.renderConstraint(lessThanConstraint));
    LengthConstraint lengthConstraint = new LengthConstraint();
    Assert.assertEquals("length: null", utils.renderConstraint(lengthConstraint));
    lengthConstraint.setLength(1);
    Assert.assertEquals("length: 1", utils.renderConstraint(lengthConstraint));
    MaxLengthConstraint maxLengthConstraint = new MaxLengthConstraint();
    Assert.assertEquals("max_length: null", utils.renderConstraint(maxLengthConstraint));
    maxLengthConstraint.setMaxLength(1);
    Assert.assertEquals("max_length: 1", utils.renderConstraint(maxLengthConstraint));
    MinLengthConstraint minLengthConstraint = new MinLengthConstraint();
    Assert.assertEquals("min_length: null", utils.renderConstraint(minLengthConstraint));
    minLengthConstraint.setMinLength(1);
    Assert.assertEquals("min_length: 1", utils.renderConstraint(minLengthConstraint));
    PatternConstraint patternConstraint = new PatternConstraint();
    Assert.assertEquals("pattern: null", utils.renderConstraint(patternConstraint));
    patternConstraint.setPattern("a");
    Assert.assertEquals("pattern: a", utils.renderConstraint(patternConstraint));
    patternConstraint.setPattern("[.*]");
    Assert.assertEquals("pattern: \"[.*]\"", utils.renderConstraint(patternConstraint));
    EqualConstraint equalConstraint = new EqualConstraint();
    Assert.assertEquals("equal: null", utils.renderConstraint(equalConstraint));
    equalConstraint.setEqual("value");
    Assert.assertEquals("equal: value", utils.renderConstraint(equalConstraint));
    equalConstraint.setEqual(" value");
    Assert.assertEquals("equal: \" value\"", utils.renderConstraint(equalConstraint));
    InRangeConstraint inRangeConstraint = new InRangeConstraint();
    Assert.assertEquals("in_range: []", utils.renderConstraint(inRangeConstraint));
    List<String> inRange = Lists.newArrayList();
    inRangeConstraint.setInRange(inRange);
    Assert.assertEquals("in_range: []", utils.renderConstraint(inRangeConstraint));
    inRange.add("1");
    Assert.assertEquals("in_range: [1]", utils.renderConstraint(inRangeConstraint));
    inRange.add("2");
    Assert.assertEquals("in_range: [1, 2]", utils.renderConstraint(inRangeConstraint));
    ValidValuesConstraint validValuesConstraint = new ValidValuesConstraint();
    Assert.assertEquals("valid_values: []", utils.renderConstraint(validValuesConstraint));
    List<String> validValues = Lists.newArrayList();
    validValuesConstraint.setValidValues(validValues);
    Assert.assertEquals("valid_values: []", utils.renderConstraint(validValuesConstraint));
    validValues.add("value1");
    Assert.assertEquals("valid_values: [value1]", utils.renderConstraint(validValuesConstraint));
    validValues.add("value2 ");
    Assert.assertEquals("valid_values: [value1, \"value2 \"]", utils.renderConstraint(validValuesConstraint));
    validValues.add("value3,value4");
    Assert.assertEquals("valid_values: [value1, \"value2 \", \"value3,value4\"]", utils.renderConstraint(validValuesConstraint));
    // finally test an unknown constraint
    AbstractPropertyConstraint abstractPropertyConstraint = new AbstractPropertyConstraint() {

        @Override
        public void validate(Object propertyValue) throws ConstraintViolationException {
        }

        @Override
        public void initialize(IPropertyType<?> propertyType) throws ConstraintValueDoNotMatchPropertyTypeException {
        }
    };
    Assert.assertEquals("", utils.renderConstraint(abstractPropertyConstraint));
}