private ParamStruct processParameter(SMInputCursor ruleC) throws XMLStreamException {
    ParamStruct param = new ParamStruct();

    // BACKWARD COMPATIBILITY WITH DEPRECATED FORMAT
    String keyAttribute = ruleC.getAttrValue("key");
    if (StringUtils.isNotBlank(keyAttribute)) {
      param.key = StringUtils.trim(keyAttribute);
    }

    // BACKWARD COMPATIBILITY WITH DEPRECATED FORMAT
    String typeAttribute = ruleC.getAttrValue("type");
    if (StringUtils.isNotBlank(typeAttribute)) {
      param.type = RuleParamType.parse(typeAttribute);
    }

    SMInputCursor paramC = ruleC.childElementCursor();
    while (paramC.getNext() != null) {
      String propNodeName = paramC.getLocalName();
      String propText = StringUtils.trim(paramC.collectDescendantText(false));
      if (StringUtils.equalsIgnoreCase("key", propNodeName)) {
        param.key = propText;

      } else if (StringUtils.equalsIgnoreCase("description", propNodeName)) {
        param.description = propText;

      } else if (StringUtils.equalsIgnoreCase("type", propNodeName)) {
        param.type = RuleParamType.parse(propText);

      } else if (StringUtils.equalsIgnoreCase("defaultValue", propNodeName)) {
        param.defaultValue = propText;
      }
    }
    return param;
  }
Example #2
0
 @Test
 public void testInteger() throws Exception {
   RuleParamType type = RuleParamType.INTEGER;
   assertThat(type.toString()).isEqualTo("INTEGER");
   assertThat(RuleParamType.parse(type.toString()).type()).isEqualTo("INTEGER");
   assertThat(RuleParamType.parse(type.toString()).values()).isEmpty();
   assertThat(RuleParamType.parse(type.toString()).toString()).isEqualTo("INTEGER");
 }
Example #3
0
  @Test
  public void testEquals() throws Exception {
    RuleParamType noOptions = RuleParamType.INTEGER;
    RuleParamType withOptions1 = RuleParamType.singleListOfValues("one", "two");
    RuleParamType withOptions2 = RuleParamType.singleListOfValues("three", "four");

    assertThat(RuleParamType.INTEGER)
        .isEqualTo(RuleParamType.INTEGER)
        .isNotEqualTo(RuleParamType.STRING)
        .isNotEqualTo("INTEGER")
        .isNotEqualTo(withOptions1)
        .isNotEqualTo(null);

    assertThat(withOptions1)
        .isEqualTo(withOptions1)
        .isNotEqualTo(noOptions)
        .isNotEqualTo(withOptions2)
        .isNotEqualTo("SINGLE_SELECT_LIST,values=one,two,")
        .isNotEqualTo(null);
  }
Example #4
0
  @Test
  public void testMultipleListOfValues() throws Exception {
    RuleParamType selectList =
        RuleParamType.parse("SINGLE_SELECT_LIST,values=\"foo,bar\",multiple=true");
    assertThat(selectList.type()).isEqualTo("SINGLE_SELECT_LIST");
    assertThat(selectList.values()).containsOnly("foo", "bar");
    assertThat(selectList.multiple()).isTrue();
    assertThat(selectList.toString())
        .isEqualTo("SINGLE_SELECT_LIST,multiple=true,values=\"foo,bar,\"");

    RuleParamType.parse("SINGLE_SELECT_LIST,\"values=foo,bar\",\"multiple=true\"");
    assertThat(selectList.type()).isEqualTo("SINGLE_SELECT_LIST");
    assertThat(selectList.values()).containsOnly("foo", "bar");
    assertThat(selectList.multiple()).isTrue();
    assertThat(selectList.toString())
        .isEqualTo("SINGLE_SELECT_LIST,multiple=true,values=\"foo,bar,\"");

    // escape values
    selectList = RuleParamType.multipleListOfValues("foo", "one,two|three,four");
    assertThat(selectList.type()).isEqualTo("SINGLE_SELECT_LIST");
    assertThat(selectList.values()).containsOnly("foo", "one,two|three,four");
    assertThat(selectList.multiple()).isTrue();
    assertThat(selectList.toString())
        .isEqualTo("SINGLE_SELECT_LIST,multiple=true,values=\"foo,\"\"one,two|three,four\"\",\"");
  }
Example #5
0
 @Test
 public void support_deprecated_formats() throws Exception {
   assertThat(RuleParamType.parse("b")).isEqualTo(RuleParamType.BOOLEAN);
   assertThat(RuleParamType.parse("i")).isEqualTo(RuleParamType.INTEGER);
   assertThat(RuleParamType.parse("i{}")).isEqualTo(RuleParamType.INTEGER);
   assertThat(RuleParamType.parse("s")).isEqualTo(RuleParamType.STRING);
   assertThat(RuleParamType.parse("s{}")).isEqualTo(RuleParamType.STRING);
   assertThat(RuleParamType.parse("r")).isEqualTo(RuleParamType.STRING);
   assertThat(RuleParamType.parse("TEXT")).isEqualTo(RuleParamType.TEXT);
   assertThat(RuleParamType.parse("STRING")).isEqualTo(RuleParamType.STRING);
   assertThat(RuleParamType.parse("REGULAR_EXPRESSION")).isEqualTo(RuleParamType.STRING);
   RuleParamType list = RuleParamType.parse("s[FOO,BAR]");
   assertThat(list.type()).isEqualTo("SINGLE_SELECT_LIST");
   assertThat(list.values()).containsOnly("FOO", "BAR");
 }