graphql.schema.CoercingParseValueException Java Examples

@Override
public String parseValue(final Object input) throws CoercingParseValueException {
  if (input instanceof UInt256Value) {
    return ((UInt256Value) input).toShortHexString();
  }
  throw new CoercingParseValueException(
      "Unable to parse variable value " + input + " as an BigInt");
}
 

@Override
public byte[] parseValue(Object input) {
    if (input instanceof String) {
        try {
            return Base64.getDecoder().decode((String) input);
        } catch (IllegalArgumentException e) {
            throw new CoercingParseValueException("Input string \"" + input + "\" is not a valid Base64 value", e);
        }
    }
    if (input instanceof byte[]) {
        return (byte[]) input;
    }
    throw valueParsingException(input, String.class, byte[].class);
}
 

@Override
public URL parseValue(Object input) {
    if (input instanceof String) {
        try {
            return new URL((String) input);
        } catch (MalformedURLException e) {
            throw new CoercingParseValueException("Input string \"" + input + "\" could not be parsed into a URL", e);
        }
    }
    if (input instanceof URL) {
        return (URL) input;
    }
    throw valueParsingException(input, String.class, URL.class);
}
 

@Override
public ShortNode parseValue(Object input) {
    if (input instanceof Number || input instanceof String) {
        try {
            return ShortNode.valueOf(new BigInteger(input.toString()).shortValueExact());
        } catch (ArithmeticException e) {
            throw new CoercingParseValueException(input + " does not fit into a short without a loss of precision");
        }
    }
    if (input instanceof ShortNode) {
        return (ShortNode) input;
    }
    throw valueParsingException(input, Number.class, String.class, ShortNode.class);
}
 

@Override
public IntNode parseValue(Object input) {
    if (input instanceof Number || input instanceof String) {
        try {
            return IntNode.valueOf(new BigInteger(input.toString()).intValueExact());
        } catch (ArithmeticException e) {
            throw new CoercingParseValueException(input + " does not fit into an int without a loss of precision");
        }
    }
    if (input instanceof IntNode) {
        return (IntNode) input;
    }
    throw valueParsingException(input, Number.class, String.class, IntNode.class);
}
 

@Override
public ByteString parseValue(Object input) throws CoercingParseValueException {
  if (input instanceof String) {
    ByteString result = ByteString.copyFromUtf8((String) input);
    if (result == null) {
      throw new CoercingParseValueException(
          "Invalid value '" + input + "' for Bytes");
    }
    return result;
  }
  if (input instanceof ByteString) {
    return (ByteString) input;
  }
  throw new CoercingParseValueException("Invalid value '" + input + "' for Bytes");
}
 

@Override
public Object parseValue(Object input) throws CoercingParseValueException {
  try {
    JsonNode jsonNode = mapper.readTree(input.toString());
    if (!jsonNode.isObject()) {
      throw new CoercingParseValueException("Expected 'ObjectNode', got: " + jsonNode);
    }
    return jsonNode;
  } catch (IOException e) {
    log.error("Error parsing value: {}", input, e);
    throw new CoercingParseValueException(e);
  }
}
 

@Override
public String parseValue(final Object input) throws CoercingParseValueException {
  if (input instanceof Address) {
    return input.toString();
  }
  throw new CoercingParseValueException(
      "Unable to parse variable value " + input + " as an Address");
}
 

@Override
public String parseValue(final Object input) throws CoercingParseValueException {
  if (input instanceof Bytes) {
    return input.toString();
  }
  throw new CoercingParseValueException(
      "Unable to parse variable value " + input + " as an Bytes");
}
 

@Override
public String parseValue(final Object input) throws CoercingParseValueException {
  if (input instanceof Bytes32) {
    return input.toString();
  }
  throw new CoercingParseValueException(
      "Unable to parse variable value " + input + " as an Bytes32");
}
 

@Override
public Number parseValue(final Object input) throws CoercingParseValueException {
  if (input instanceof Number) {
    return (Number) input;
  } else if (input instanceof String) {
    final String value = ((String) input).toLowerCase();
    if (value.startsWith("0x")) {
      return Bytes.fromHexStringLenient(value).toLong();
    } else {
      return Long.parseLong(value);
    }
  }
  throw new CoercingParseValueException(
      "Unable to parse variable value " + input + " as an Long");
}
 

@Test
public void pareValueErrorTest() {

  thrown.expect(CoercingParseValueException.class);
  scalar.getCoercing().parseValue(addrStr);
}
 

public static CoercingParseValueException valueParsingException(
    Object input, Class<?>... allowedTypes) {
  return new CoercingParseValueException(errorMessage(input, allowedTypes));
}
 

@Override
public Object parseValue(Object input) {
    throw new CoercingParseValueException(ERROR);
}
 

public static CoercingParseValueException valueParsingException(Object input, Class... allowedTypes) {
    return new CoercingParseValueException(errorMessage(input, allowedTypes));
}
 

@Override
public Object parseValue(Object input) {
    throw new CoercingParseValueException("Class can not be used as input");
}
 

@Test
public void pareValueErrorTest() {
  thrown.expect(CoercingParseValueException.class);
  scalar.getCoercing().parseValue(str);
}
 

@Test(expected = CoercingParseValueException.class)
public void parseValueNotValidJson() {
  underTest.parseValue("{");
}
 

@Test(expected = CoercingParseValueException.class)
public void parseValueNotAnObjectNode() {
  underTest.parseValue("[]");
}
 

@Test
public void pareValueErrorTest() {
  thrown.expect(CoercingParseValueException.class);
  scalar.getCoercing().parseValue(invalidStrValue);
}
 

@Message(id = 13, value = "Expected type [%s] but was [%s].")
CoercingParseValueException coercingParseValueException(String expectedType, String actualType, @Cause Exception cause);
 

@Override
public Object parseValue(Object input) throws CoercingParseValueException {
    return input;
}
 

@Test
public void pareValueErrorTest() {
  thrown.expect(CoercingParseValueException.class);
  scalar.getCoercing().parseValue(str);
}
 

@Test
public void pareValueErrorTest() {
  thrown.expect(CoercingParseValueException.class);
  scalar.getCoercing().parseValue(str);
}