@BeforeTest
  public void createEntity() {
    entityType = when(mock(EntityType.class).getName()).thenReturn("Source").getMock();
    Attribute idAttr = when(mock(Attribute.class).getName()).thenReturn("Identifier").getMock();

    when(idAttr.getDataType()).thenReturn(INT);
    Attribute intAttr = when(mock(Attribute.class).getName()).thenReturn("Int").getMock();
    when(intAttr.getDataType()).thenReturn(INT);
    Attribute stringAttr = when(mock(Attribute.class).getName()).thenReturn("String").getMock();
    when(stringAttr.getDataType()).thenReturn(STRING);
    Attribute nonNumericStringAttr =
        when(mock(Attribute.class).getName()).thenReturn("NonNumericString").getMock();
    when(nonNumericStringAttr.getDataType()).thenReturn(STRING);
    Attribute longAttr = when(mock(Attribute.class).getName()).thenReturn("Long").getMock();
    when(longAttr.getDataType()).thenReturn(LONG);
    when(entityType.getIdAttribute()).thenReturn(idAttr);
    when(entityType.getAttribute("Identifier")).thenReturn(idAttr);
    when(entityType.getAttribute("Int")).thenReturn(intAttr);
    when(entityType.getAttribute("String")).thenReturn(stringAttr);
    when(entityType.getAttribute("NonNumericString")).thenReturn(nonNumericStringAttr);
    when(entityType.getAttribute("Long")).thenReturn(longAttr);

    entity = new DynamicEntity(entityType);
    entity.set("Int", 1);
    entity.set("String", "12");
    entity.set("Long", 10L);
    entity.set("NonNumericString", "Hello World!");
  }
 @Test
 public void testStringEvaluatorLookupAttributeAndConvertFromIntToLong() {
   Attribute amd = when(mock(Attribute.class).getName()).thenReturn("#POS").getMock();
   when(amd.getDataType()).thenReturn(LONG);
   when(amd.getExpression()).thenReturn("Int");
   assertEquals(new StringExpressionEvaluator(amd, entityType).evaluate(entity), 1L);
 }
 @Test(
     expectedExceptions = ConversionFailedException.class,
     expectedExceptionsMessageRegExp =
         "Failed to convert from type \\[java.lang.String\\] to type \\[java.lang.Long\\] for value 'Hello World!'; nested exception is java.lang.NumberFormatException: For input string: \"HelloWorld!\"")
 public void testStringEvaluatorLookupAttributeAndConvertFromNonNumericStringToLongFails() {
   Attribute amd = when(mock(Attribute.class).getName()).thenReturn("#POS").getMock();
   when(amd.getDataType()).thenReturn(LONG);
   when(amd.getExpression()).thenReturn("NonNumericString");
   new StringExpressionEvaluator(amd, entityType).evaluate(entity);
 }
 @Test
 public void testStringEvaluatorConstructorChecksIfExpressionIsMap() {
   Attribute amd = when(mock(Attribute.class).getName()).thenReturn("#CHROM").getMock();
   when(amd.getDataType()).thenReturn(STRING);
   when(amd.getExpression()).thenReturn("{}");
   try {
     new StringExpressionEvaluator(amd, entityType);
     fail("expected illegal state exception");
   } catch (JsonSyntaxException expected) {
   }
 }
 @Test
 public void testStringEvaluatorConstructorChecksIfAttributeHasExpression() {
   Attribute amd = when(mock(Attribute.class).getName()).thenReturn("#CHROM").getMock();
   when(amd.getDataType()).thenReturn(STRING);
   try {
     new StringExpressionEvaluator(amd, entityType);
     fail("Expected NPE");
   } catch (NullPointerException expected) {
     assertEquals(expected.getMessage(), "Attribute has no expression.");
   }
 }
 private Object toQueryRuleValue(Object queryRuleValue, Attribute attr) {
   Object value;
   AttributeType attrType = attr.getDataType();
   switch (attrType) {
     case BOOL:
       value = convertBool(attr, queryRuleValue);
       break;
     case EMAIL:
     case HTML:
     case HYPERLINK:
     case SCRIPT:
     case STRING:
     case TEXT:
       value = convertString(attr, queryRuleValue);
       break;
     case ENUM:
       value = convertEnum(attr, queryRuleValue);
       break;
     case CATEGORICAL:
     case XREF:
     case CATEGORICAL_MREF:
     case MREF:
     case ONE_TO_MANY:
       value = convertRef(attr, queryRuleValue);
       break;
     case DATE:
       value = convertDate(attr, queryRuleValue);
       break;
     case DATE_TIME:
       value = convertDateTime(attr, queryRuleValue);
       break;
     case DECIMAL:
       value = convertDecimal(attr, queryRuleValue);
       break;
     case FILE:
       value = convertFile(attr, queryRuleValue);
       break;
     case INT:
       value = convertInt(attr, queryRuleValue);
       break;
     case LONG:
       value = convertLong(attr, queryRuleValue);
       break;
     case COMPOUND:
       throw new MolgenisValidationException(
           new ConstraintViolation(
               format(
                   "Attribute [%s] type [%s] is not allowed",
                   attr.getName(), attrType.toString())));
     default:
       throw new RuntimeException(format("Unknown attribute type [%s]", attrType.toString()));
   }
   return value;
 }
 @Test
 public void testStringEvaluatorConstructorChecksIfAttributeMentionsExistingAttribute() {
   Attribute amd = when(mock(Attribute.class).getName()).thenReturn("#CHROM").getMock();
   when(amd.getDataType()).thenReturn(STRING);
   when(amd.getExpression()).thenReturn("bogus");
   try {
     new StringExpressionEvaluator(amd, entityType);
     fail("expected illegal argument exception");
   } catch (IllegalArgumentException expected) {
     assertEquals(
         expected.getMessage(),
         "Expression for attribute '#CHROM' references non-existant attribute 'bogus'.");
   }
 }
  /**
   * Validate is value is of the type defined by the attribute data type.
   *
   * @param attrName attribute name
   * @param value value (must be of the type defined by the attribute data type.)
   */
  protected void validateValueType(String attrName, Object value) {
    if (value == null) {
      return;
    }

    Attribute attr = entityType.getAttribute(attrName);
    if (attr == null) {
      throw new UnknownAttributeException(format("Unknown attribute [%s]", attrName));
    }

    AttributeType dataType = attr.getDataType();
    switch (dataType) {
      case BOOL:
        if (!(value instanceof Boolean)) {
          throw new MolgenisDataException(
              format(
                  "Value [%s] is of type [%s] instead of [%s] for attribute: [%s]",
                  value.toString(),
                  value.getClass().getSimpleName(),
                  Boolean.class.getSimpleName(),
                  attrName));
        }
        break;
      case CATEGORICAL:
        // expected type is FileMeta. validation is not possible because molgenis-data does not
        // depend on molgenis-file
      case FILE:
      case XREF:
        if (!(value instanceof Entity)) {
          throw new MolgenisDataException(
              format(
                  "Value [%s] is of type [%s] instead of [%s] for attribute: [%s]",
                  value.toString(),
                  value.getClass().getSimpleName(),
                  Entity.class.getSimpleName(),
                  attrName));
        }
        break;
      case CATEGORICAL_MREF:
      case MREF:
      case ONE_TO_MANY:
        if (!(value instanceof Iterable)) {
          throw new MolgenisDataException(
              format(
                  "Value [%s] is of type [%s] instead of [%s] for attribute: [%s]",
                  value.toString(),
                  value.getClass().getSimpleName(),
                  Iterable.class.getSimpleName(),
                  attrName));
        }
        break;
      case COMPOUND:
        throw new IllegalArgumentException(
            format("Unexpected data type [%s] for attribute: [%s]", dataType.toString(), attrName));
      case DATE:
      case DATE_TIME:
        if (!(value instanceof java.util.Date)) {
          throw new MolgenisDataException(
              format(
                  "Value [%s] is of type [%s] instead of [%s] for attribute: [%s]",
                  value.toString(),
                  value.getClass().getSimpleName(),
                  java.util.Date.class.getSimpleName(),
                  attrName));
        }
        break;
      case DECIMAL:
        if (!(value instanceof Double)) {
          throw new MolgenisDataException(
              format(
                  "Value [%s] is of type [%s] instead of [%s] for attribute: [%s]",
                  value.toString(),
                  value.getClass().getSimpleName(),
                  Double.class.getSimpleName(),
                  attrName));
        }
        break;
      case EMAIL:
      case ENUM:
      case HTML:
      case HYPERLINK:
      case SCRIPT:
      case STRING:
      case TEXT:
        if (!(value instanceof String)) {
          throw new MolgenisDataException(
              format(
                  "Value [%s] is of type [%s] instead of [%s] for attribute: [%s]",
                  value.toString(),
                  value.getClass().getSimpleName(),
                  String.class.getSimpleName(),
                  attrName));
        }
        break;
      case INT:
        if (!(value instanceof Integer)) {
          throw new MolgenisDataException(
              format(
                  "Value [%s] is of type [%s] instead of [%s] for attribute: [%s]",
                  value.toString(),
                  value.getClass().getSimpleName(),
                  Integer.class.getSimpleName(),
                  attrName));
        }
        break;
      case LONG:
        if (!(value instanceof Long)) {
          throw new MolgenisDataException(
              format(
                  "Value [%s] is of type [%s] instead of [%s] for attribute: [%s]",
                  value.toString(),
                  value.getClass().getSimpleName(),
                  Long.class.getSimpleName(),
                  attrName));
        }
        break;
      default:
        throw new RuntimeException(format("Unknown data type [%s]", dataType.toString()));
    }
  }