From 7cab18e9789c6e0bce0043190fad283c9138fe7d Mon Sep 17 00:00:00 2001 From: Danno Ferrin Date: Wed, 12 Oct 2022 16:49:15 -0600 Subject: [PATCH] Make GraphQL scalar parsing compatible with variables (#4522) Our current GraphQL scalar parsing interacts poorly with the variables support in the library. Revise the parsing so it works correctly. Signed-off-by: Danno Ferrin --- CHANGELOG.md | 1 + .../api/graphql/internal/Scalars.java | 254 ++++++++++++------ .../api/graphql/EthGraphQLHttpBySpecTest.java | 13 +- .../api/graphql/scalar/AddressScalarTest.java | 13 +- .../api/graphql/scalar/BigIntScalarTest.java | 14 +- .../api/graphql/scalar/Bytes32ScalarTest.java | 13 +- .../api/graphql/scalar/BytesScalarTest.java | 13 +- .../api/graphql/scalar/LongScalarTest.java | 3 - .../api/graphql/graphql_variable_address.json | 14 + .../api/graphql/graphql_variable_bytes.json | 10 + .../api/graphql/graphql_variable_bytes32.json | 12 + .../api/graphql/graphql_variable_long.json | 17 ++ 12 files changed, 254 insertions(+), 123 deletions(-) create mode 100644 ethereum/api/src/test/resources/org/hyperledger/besu/ethereum/api/graphql/graphql_variable_address.json create mode 100644 ethereum/api/src/test/resources/org/hyperledger/besu/ethereum/api/graphql/graphql_variable_bytes.json create mode 100644 ethereum/api/src/test/resources/org/hyperledger/besu/ethereum/api/graphql/graphql_variable_bytes32.json create mode 100644 ethereum/api/src/test/resources/org/hyperledger/besu/ethereum/api/graphql/graphql_variable_long.json diff --git a/CHANGELOG.md b/CHANGELOG.md index 9c5076f289b..7e429e1a4f5 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -21,6 +21,7 @@ - Corrects emission of blockadded events when rewinding during a re-org. Fix for [#4495](https://github.com/hyperledger/besu/issues/4495) - Always return a transaction type for pending transactions [#4364](https://github.com/hyperledger/besu/pull/4364) - Avoid a cyclic reference while printing EngineExchangeTransitionConfigurationParameter [#4357](https://github.com/hyperledger/besu/pull/4357) +- In GraphQL update scalar parsing to be variable friendly [#4522](https://github.com/hyperledger/besu/pull/4522) ### Download Links diff --git a/ethereum/api/src/main/java/org/hyperledger/besu/ethereum/api/graphql/internal/Scalars.java b/ethereum/api/src/main/java/org/hyperledger/besu/ethereum/api/graphql/internal/Scalars.java index ac396c3d5b0..bfaf092b3d7 100644 --- a/ethereum/api/src/main/java/org/hyperledger/besu/ethereum/api/graphql/internal/Scalars.java +++ b/ethereum/api/src/main/java/org/hyperledger/besu/ethereum/api/graphql/internal/Scalars.java @@ -15,7 +15,6 @@ package org.hyperledger.besu.ethereum.api.graphql.internal; import org.hyperledger.besu.datatypes.Address; -import org.hyperledger.besu.datatypes.Hash; import org.hyperledger.besu.ethereum.api.jsonrpc.internal.results.Quantity; import graphql.language.IntValue; @@ -28,156 +27,239 @@ import org.apache.tuweni.bytes.Bytes; import org.apache.tuweni.bytes.Bytes32; import org.apache.tuweni.units.bigints.UInt256; -import org.apache.tuweni.units.bigints.UInt256Value; public class Scalars { - private static final Coercing ADDRESS_COERCING = - new Coercing() { + private Scalars() {} + + private static final Coercing ADDRESS_COERCING = + new Coercing() { + Address convertImpl(final Object input) { + if (input instanceof Address) { + return (Address) input; + } else if (input instanceof Bytes) { + if (((Bytes) input).size() <= 20) { + return Address.wrap((Bytes) input); + } else { + return null; + } + } else if (input instanceof StringValue) { + return convertImpl(((StringValue) input).getValue()); + } else if (input instanceof String) { + try { + return Address.fromHexStringStrict((String) input); + } catch (IllegalArgumentException iae) { + return null; + } + } else { + return null; + } + } + @Override public String serialize(final Object input) throws CoercingSerializeException { - if (input instanceof Address) { - return input.toString(); + Address result = convertImpl(input); + if (result != null) { + return result.toHexString(); + } else { + throw new CoercingSerializeException("Unable to serialize " + input + " as an Address"); } - throw new CoercingSerializeException("Unable to serialize " + input + " as an Address"); } @Override - public String parseValue(final Object input) throws CoercingParseValueException { - if (input instanceof Address) { - return input.toString(); + public Address parseValue(final Object input) throws CoercingParseValueException { + Address result = convertImpl(input); + if (result != null) { + return result; + } else { + throw new CoercingParseValueException( + "Unable to parse variable value " + input + " as an Address"); } - throw new CoercingParseValueException( - "Unable to parse variable value " + input + " as an Address"); } @Override public Address parseLiteral(final Object input) throws CoercingParseLiteralException { - if (!(input instanceof StringValue)) { - throw new CoercingParseLiteralException("Value is not any Address : '" + input + "'"); - } - String inputValue = ((StringValue) input).getValue(); - try { - return Address.fromHexStringStrict(inputValue); - } catch (final IllegalArgumentException e) { + Address result = convertImpl(input); + if (result != null) { + return result; + } else { throw new CoercingParseLiteralException("Value is not any Address : '" + input + "'"); } } }; - private static final Coercing BIG_INT_COERCING = - new Coercing() { + private static final Coercing BIG_INT_COERCING = + new Coercing() { + + String convertImpl(final Object input) { + if (input instanceof String) { + try { + return Bytes.fromHexStringLenient((String) input).toShortHexString(); + } catch (IllegalArgumentException iae) { + return null; + } + } else if (input instanceof Bytes) { + return ((Bytes) input).toShortHexString(); + } else if (input instanceof StringValue) { + return convertImpl(((StringValue) input).getValue()); + } else if (input instanceof IntValue) { + return UInt256.valueOf(((IntValue) input).getValue()).toShortHexString(); + } else { + return null; + } + } + @Override public String serialize(final Object input) throws CoercingSerializeException { - if (input instanceof UInt256Value) { - return ((UInt256Value) input).toShortHexString(); + var result = convertImpl(input); + if (result != null) { + return result; + } else { + throw new CoercingSerializeException("Unable to serialize " + input + " as an BigInt"); } - throw new CoercingSerializeException("Unable to serialize " + input + " as an BigInt"); } @Override public String parseValue(final Object input) throws CoercingParseValueException { - if (input instanceof UInt256Value) { - return ((UInt256Value) input).toShortHexString(); + var result = convertImpl(input); + if (result != null) { + return result; + } else { + throw new CoercingParseValueException( + "Unable to parse variable value " + input + " as an BigInt"); } - throw new CoercingParseValueException( - "Unable to parse variable value " + input + " as an BigInt"); } @Override - public UInt256 parseLiteral(final Object input) throws CoercingParseLiteralException { - try { - if (input instanceof StringValue) { - return UInt256.fromHexString(((StringValue) input).getValue()); - } else if (input instanceof IntValue) { - return UInt256.valueOf(((IntValue) input).getValue()); - } - } catch (final IllegalArgumentException e) { - // fall through + public String parseLiteral(final Object input) throws CoercingParseLiteralException { + var result = convertImpl(input); + if (result != null) { + return result; + } else { + throw new CoercingParseLiteralException("Value is not any BigInt : '" + input + "'"); } - throw new CoercingParseLiteralException("Value is not any BigInt : '" + input + "'"); } }; - private static final Coercing BYTES_COERCING = - new Coercing() { + private static final Coercing BYTES_COERCING = + new Coercing() { + + Bytes convertImpl(final Object input) { + if (input instanceof Bytes) { + return (Bytes) input; + } else if (input instanceof StringValue) { + return convertImpl(((StringValue) input).getValue()); + } else if (input instanceof String) { + if (!Quantity.isValid((String) input)) { + throw new CoercingParseLiteralException( + "Bytes value '" + input + "' is not prefixed with 0x"); + } + try { + return Bytes.fromHexStringLenient((String) input); + } catch (IllegalArgumentException iae) { + return null; + } + } else { + return null; + } + } + @Override public String serialize(final Object input) throws CoercingSerializeException { - if (input instanceof Bytes) { - return input.toString(); + var result = convertImpl(input); + if (result != null) { + return result.toHexString(); + } else { + throw new CoercingSerializeException("Unable to serialize " + input + " as an Bytes"); } - throw new CoercingSerializeException("Unable to serialize " + input + " as an Bytes"); } @Override - public String parseValue(final Object input) throws CoercingParseValueException { - if (input instanceof Bytes) { - return input.toString(); + public Bytes parseValue(final Object input) throws CoercingParseValueException { + var result = convertImpl(input); + if (result != null) { + return result; + } else { + throw new CoercingParseValueException( + "Unable to parse variable value " + input + " as an Bytes"); } - throw new CoercingParseValueException( - "Unable to parse variable value " + input + " as an Bytes"); } @Override public Bytes parseLiteral(final Object input) throws CoercingParseLiteralException { - if (!(input instanceof StringValue)) { - throw new CoercingParseLiteralException("Value is not any Bytes : '" + input + "'"); - } - String inputValue = ((StringValue) input).getValue(); - if (!Quantity.isValid(inputValue)) { - throw new CoercingParseLiteralException( - "Bytes value '" + inputValue + "' is not prefixed with 0x"); - } - try { - return Bytes.fromHexStringLenient(inputValue); - } catch (final IllegalArgumentException e) { + var result = convertImpl(input); + if (result != null) { + return result; + } else { throw new CoercingParseLiteralException("Value is not any Bytes : '" + input + "'"); } } }; - private static final Coercing BYTES32_COERCING = - new Coercing() { + private static final Coercing BYTES32_COERCING = + new Coercing() { + + Bytes32 convertImpl(final Object input) { + if (input instanceof Bytes32) { + return (Bytes32) input; + } else if (input instanceof Bytes) { + if (((Bytes) input).size() <= 32) { + return Bytes32.leftPad((Bytes) input); + } else { + return null; + } + } else if (input instanceof StringValue) { + return convertImpl((((StringValue) input).getValue())); + } else if (input instanceof String) { + if (!Quantity.isValid((String) input)) { + throw new CoercingParseLiteralException( + "Bytes32 value '" + input + "' is not prefixed with 0x"); + } else { + try { + return Bytes32.fromHexStringLenient((String) input); + } catch (IllegalArgumentException iae) { + return null; + } + } + } else { + return null; + } + } + @Override public String serialize(final Object input) throws CoercingSerializeException { - if (input instanceof Hash) { - return ((Hash) input).toString(); - } - if (input instanceof Bytes32) { - return input.toString(); + var result = convertImpl(input); + if (result == null) { + throw new CoercingSerializeException("Unable to serialize " + input + " as an Bytes32"); + } else { + return result.toHexString(); } - throw new CoercingSerializeException("Unable to serialize " + input + " as an Bytes32"); } @Override - public String parseValue(final Object input) throws CoercingParseValueException { - if (input instanceof Bytes32) { - return input.toString(); + public Bytes32 parseValue(final Object input) throws CoercingParseValueException { + var result = convertImpl(input); + if (result == null) { + throw new CoercingParseValueException( + "Unable to parse variable value " + input + " as an Bytes32"); + } else { + return result; } - throw new CoercingParseValueException( - "Unable to parse variable value " + input + " as an Bytes32"); } @Override public Bytes32 parseLiteral(final Object input) throws CoercingParseLiteralException { - if (!(input instanceof StringValue)) { - throw new CoercingParseLiteralException("Value is not any Bytes32 : '" + input + "'"); - } - String inputValue = ((StringValue) input).getValue(); - if (!Quantity.isValid(inputValue)) { - throw new CoercingParseLiteralException( - "Bytes32 value '" + inputValue + "' is not prefixed with 0x"); - } - try { - return Bytes32.fromHexStringLenient(inputValue); - } catch (final IllegalArgumentException e) { + var result = convertImpl(input); + if (result == null) { throw new CoercingParseLiteralException("Value is not any Bytes32 : '" + input + "'"); + } else { + return result; } } }; - private static final Coercing LONG_COERCING = - new Coercing() { + private static final Coercing LONG_COERCING = + new Coercing() { @Override public Number serialize(final Object input) throws CoercingSerializeException { if (input instanceof Number) { @@ -210,7 +292,7 @@ public Number parseValue(final Object input) throws CoercingParseValueException } @Override - public Object parseLiteral(final Object input) throws CoercingParseLiteralException { + public Number parseLiteral(final Object input) throws CoercingParseLiteralException { try { if (input instanceof IntValue) { return ((IntValue) input).getValue().longValue(); diff --git a/ethereum/api/src/test/java/org/hyperledger/besu/ethereum/api/graphql/EthGraphQLHttpBySpecTest.java b/ethereum/api/src/test/java/org/hyperledger/besu/ethereum/api/graphql/EthGraphQLHttpBySpecTest.java index 6dedc04a36e..a2280923d9c 100644 --- a/ethereum/api/src/test/java/org/hyperledger/besu/ethereum/api/graphql/EthGraphQLHttpBySpecTest.java +++ b/ethereum/api/src/test/java/org/hyperledger/besu/ethereum/api/graphql/EthGraphQLHttpBySpecTest.java @@ -113,6 +113,11 @@ public static Collection specs() { specs.add("graphql_tooComplex"); specs.add("graphql_tooComplexSchema"); + specs.add("graphql_variable_address"); + specs.add("graphql_variable_bytes"); + specs.add("graphql_variable_bytes32"); + specs.add("graphql_variable_long"); + return specs; } @@ -128,7 +133,13 @@ private void graphQLCall(final String name) throws IOException { EthGraphQLHttpBySpecTest.class.getResource(testSpecFile), Charsets.UTF_8); final JsonObject spec = new JsonObject(json); final String rawRequestBody = spec.getString("request"); - final RequestBody requestBody = RequestBody.create(rawRequestBody, GRAPHQL); + final String rawVariables = spec.getString("variables"); + final RequestBody requestBody = + rawVariables == null + ? RequestBody.create(rawRequestBody, GRAPHQL) + : RequestBody.create( + "{ \"query\":\"" + rawRequestBody + "\", \"variables\": " + rawVariables + "}", + JSON); final Request request = new Request.Builder().post(requestBody).url(baseUrl).build(); importBlocks(1, BLOCKS.size()); diff --git a/ethereum/api/src/test/java/org/hyperledger/besu/ethereum/api/graphql/scalar/AddressScalarTest.java b/ethereum/api/src/test/java/org/hyperledger/besu/ethereum/api/graphql/scalar/AddressScalarTest.java index 33a0e59289c..87153b49087 100644 --- a/ethereum/api/src/test/java/org/hyperledger/besu/ethereum/api/graphql/scalar/AddressScalarTest.java +++ b/ethereum/api/src/test/java/org/hyperledger/besu/ethereum/api/graphql/scalar/AddressScalarTest.java @@ -27,10 +27,7 @@ import graphql.schema.GraphQLScalarType; import org.junit.Before; import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.junit.MockitoJUnitRunner; -@RunWith(MockitoJUnitRunner.class) public class AddressScalarTest { private GraphQLScalarType scalar; @@ -43,13 +40,13 @@ public class AddressScalarTest { @Test public void parseValueTest() { - final String result = (String) scalar.getCoercing().parseValue(addr); - assertThat(result).isEqualTo(addrStr); + final Address result = (Address) scalar.getCoercing().parseValue(addrStr); + assertThat(result).isEqualTo(addr); } @Test public void parseValueErrorTest() { - assertThatThrownBy(() -> scalar.getCoercing().parseValue(addrStr)) + assertThatThrownBy(() -> scalar.getCoercing().parseValue(3.4f)) .isInstanceOf(CoercingParseValueException.class); } @@ -61,7 +58,7 @@ public void serializeTest() { @Test public void serializeErrorTest() { - assertThatThrownBy(() -> scalar.getCoercing().serialize(addrStr)) + assertThatThrownBy(() -> scalar.getCoercing().serialize(3.4f)) .isInstanceOf(CoercingSerializeException.class); } @@ -73,7 +70,7 @@ public void parseLiteralTest() { @Test public void parseLiteralErrorTest() { - assertThatThrownBy(() -> scalar.getCoercing().parseLiteral(addrStr)) + assertThatThrownBy(() -> scalar.getCoercing().parseLiteral(3.4f)) .isInstanceOf(CoercingParseLiteralException.class); } diff --git a/ethereum/api/src/test/java/org/hyperledger/besu/ethereum/api/graphql/scalar/BigIntScalarTest.java b/ethereum/api/src/test/java/org/hyperledger/besu/ethereum/api/graphql/scalar/BigIntScalarTest.java index 4f0ac678882..06fcfa42c2f 100644 --- a/ethereum/api/src/test/java/org/hyperledger/besu/ethereum/api/graphql/scalar/BigIntScalarTest.java +++ b/ethereum/api/src/test/java/org/hyperledger/besu/ethereum/api/graphql/scalar/BigIntScalarTest.java @@ -27,17 +27,13 @@ import org.apache.tuweni.units.bigints.UInt256; import org.junit.Before; import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.junit.MockitoJUnitRunner; -@RunWith(MockitoJUnitRunner.class) public class BigIntScalarTest { private GraphQLScalarType scalar; private final String str = "0x10"; private final UInt256 value = UInt256.fromHexString(str); - private final StringValue strValue = StringValue.newStringValue(str).build(); private final StringValue invalidStrValue = StringValue.newStringValue("0xgh").build(); @Test @@ -48,7 +44,7 @@ public void parseValueTest() { @Test public void parseValueErrorTest() { - assertThatThrownBy(() -> scalar.getCoercing().parseValue(str)) + assertThatThrownBy(() -> scalar.getCoercing().parseValue(3.2)) .isInstanceOf(CoercingParseValueException.class); } @@ -60,19 +56,19 @@ public void serializeTest() { @Test public void serializeErrorTest() { - assertThatThrownBy(() -> scalar.getCoercing().serialize(str)) + assertThatThrownBy(() -> scalar.getCoercing().serialize(3.2)) .isInstanceOf(CoercingSerializeException.class); } @Test public void parseLiteralTest() { - final UInt256 result = (UInt256) scalar.getCoercing().parseLiteral(strValue); - assertThat(result).isEqualTo(value); + final String result = (String) scalar.getCoercing().parseLiteral(value); + assertThat(result).isEqualTo(str); } @Test public void parseLiteralErrorTest() { - assertThatThrownBy(() -> scalar.getCoercing().parseLiteral(str)) + assertThatThrownBy(() -> scalar.getCoercing().parseLiteral(3.2)) .isInstanceOf(CoercingParseLiteralException.class); } diff --git a/ethereum/api/src/test/java/org/hyperledger/besu/ethereum/api/graphql/scalar/Bytes32ScalarTest.java b/ethereum/api/src/test/java/org/hyperledger/besu/ethereum/api/graphql/scalar/Bytes32ScalarTest.java index 56fc6c0e072..47e516c3b52 100644 --- a/ethereum/api/src/test/java/org/hyperledger/besu/ethereum/api/graphql/scalar/Bytes32ScalarTest.java +++ b/ethereum/api/src/test/java/org/hyperledger/besu/ethereum/api/graphql/scalar/Bytes32ScalarTest.java @@ -27,10 +27,7 @@ import org.apache.tuweni.bytes.Bytes32; import org.junit.Before; import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.junit.MockitoJUnitRunner; -@RunWith(MockitoJUnitRunner.class) public class Bytes32ScalarTest { private GraphQLScalarType scalar; @@ -42,13 +39,13 @@ public class Bytes32ScalarTest { @Test public void pareValueTest() { - final String result = (String) scalar.getCoercing().parseValue(value); - assertThat(result).isEqualTo(str); + final var result = scalar.getCoercing().parseValue(str); + assertThat(result).isEqualTo(value); } @Test public void parseValueErrorTest() { - assertThatThrownBy(() -> scalar.getCoercing().parseValue(str)) + assertThatThrownBy(() -> scalar.getCoercing().parseValue(3.2f)) .isInstanceOf(CoercingParseValueException.class); } @@ -60,7 +57,7 @@ public void serializeTest() { @Test public void serializeErrorTest() { - assertThatThrownBy(() -> scalar.getCoercing().serialize(str)) + assertThatThrownBy(() -> scalar.getCoercing().serialize(3.2f)) .isInstanceOf(CoercingSerializeException.class); } @@ -72,7 +69,7 @@ public void parseLiteralTest() { @Test public void parseLiteralErrorTest() { - assertThatThrownBy(() -> scalar.getCoercing().parseLiteral(str)) + assertThatThrownBy(() -> scalar.getCoercing().parseLiteral(3.2f)) .isInstanceOf(CoercingParseLiteralException.class); } diff --git a/ethereum/api/src/test/java/org/hyperledger/besu/ethereum/api/graphql/scalar/BytesScalarTest.java b/ethereum/api/src/test/java/org/hyperledger/besu/ethereum/api/graphql/scalar/BytesScalarTest.java index 493135d95f2..39ca321c3a5 100644 --- a/ethereum/api/src/test/java/org/hyperledger/besu/ethereum/api/graphql/scalar/BytesScalarTest.java +++ b/ethereum/api/src/test/java/org/hyperledger/besu/ethereum/api/graphql/scalar/BytesScalarTest.java @@ -27,10 +27,7 @@ import org.apache.tuweni.bytes.Bytes; import org.junit.Before; import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.junit.MockitoJUnitRunner; -@RunWith(MockitoJUnitRunner.class) public class BytesScalarTest { private GraphQLScalarType scalar; @@ -42,13 +39,13 @@ public class BytesScalarTest { @Test public void parseValueTest() { - final String result = (String) scalar.getCoercing().parseValue(value); - assertThat(result).isEqualTo(str); + final var result = scalar.getCoercing().parseValue(str); + assertThat(result).isEqualTo(value); } @Test public void parseValueErrorTest() { - assertThatThrownBy(() -> scalar.getCoercing().parseValue(str)) + assertThatThrownBy(() -> scalar.getCoercing().parseValue(3.2f)) .isInstanceOf(CoercingParseValueException.class); } @@ -60,7 +57,7 @@ public void serializeTest() { @Test public void serializeErrorTest() { - assertThatThrownBy(() -> scalar.getCoercing().serialize(str)) + assertThatThrownBy(() -> scalar.getCoercing().serialize(3.2f)) .isInstanceOf(CoercingSerializeException.class); } @@ -72,7 +69,7 @@ public void parseLiteralTest() { @Test public void parseLiteralErrorTest() { - assertThatThrownBy(() -> scalar.getCoercing().parseLiteral(str)) + assertThatThrownBy(() -> scalar.getCoercing().parseLiteral(3.2f)) .isInstanceOf(CoercingParseLiteralException.class); } diff --git a/ethereum/api/src/test/java/org/hyperledger/besu/ethereum/api/graphql/scalar/LongScalarTest.java b/ethereum/api/src/test/java/org/hyperledger/besu/ethereum/api/graphql/scalar/LongScalarTest.java index 5a1cfad7af4..d693d6e2c95 100644 --- a/ethereum/api/src/test/java/org/hyperledger/besu/ethereum/api/graphql/scalar/LongScalarTest.java +++ b/ethereum/api/src/test/java/org/hyperledger/besu/ethereum/api/graphql/scalar/LongScalarTest.java @@ -26,10 +26,7 @@ import graphql.schema.GraphQLScalarType; import org.junit.Before; import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.junit.MockitoJUnitRunner; -@RunWith(MockitoJUnitRunner.class) public class LongScalarTest { private GraphQLScalarType scalar; diff --git a/ethereum/api/src/test/resources/org/hyperledger/besu/ethereum/api/graphql/graphql_variable_address.json b/ethereum/api/src/test/resources/org/hyperledger/besu/ethereum/api/graphql/graphql_variable_address.json new file mode 100644 index 00000000000..79a162dd1bb --- /dev/null +++ b/ethereum/api/src/test/resources/org/hyperledger/besu/ethereum/api/graphql/graphql_variable_address.json @@ -0,0 +1,14 @@ +{ + "variables": "{ \"address\": \"0x6295ee1b4f6dd65047762f924ecd367c17eabf8f\"}", + "request": "query getAddressBalance($address :Address!) { pending { account(address:$address) { balance} } }", + "response": { + "data": { + "pending": { + "account": { + "balance": "0x140" + } + } + } + }, + "statusCode": 200 +} \ No newline at end of file diff --git a/ethereum/api/src/test/resources/org/hyperledger/besu/ethereum/api/graphql/graphql_variable_bytes.json b/ethereum/api/src/test/resources/org/hyperledger/besu/ethereum/api/graphql/graphql_variable_bytes.json new file mode 100644 index 00000000000..c65dc75e41c --- /dev/null +++ b/ethereum/api/src/test/resources/org/hyperledger/besu/ethereum/api/graphql/graphql_variable_bytes.json @@ -0,0 +1,10 @@ +{ + "variables" : "{ \"data\": \"0xf86d0485174876e800830222e0945aae326516b4f8fe08074b7e972e40a713048d62880de0b6b3a7640000801ba05d4e7998757264daab67df2ce6f7e7a0ae36910778a406ca73898c9899a32b9ea0674700d5c3d1d27f2e6b4469957dfd1a1c49bf92383d80717afc84eb05695d5b\"}", + "request" : "mutation postTransaction($data: Bytes!) { sendRawTransaction(data: $data) }", + "response":{ + "data" : { + "sendRawTransaction" : "0xbaabcc1bd699e7378451e4ce5969edb9bdcae76cb79bdacae793525c31e423c7" + } + }, + "statusCode": 200 +} \ No newline at end of file diff --git a/ethereum/api/src/test/resources/org/hyperledger/besu/ethereum/api/graphql/graphql_variable_bytes32.json b/ethereum/api/src/test/resources/org/hyperledger/besu/ethereum/api/graphql/graphql_variable_bytes32.json new file mode 100644 index 00000000000..1512cbdc402 --- /dev/null +++ b/ethereum/api/src/test/resources/org/hyperledger/besu/ethereum/api/graphql/graphql_variable_bytes32.json @@ -0,0 +1,12 @@ +{ + "variables": "{ \"hash\": \"0xc8df1f061abb4d0c107b2b1a794ade8780b3120e681f723fe55a7be586d95ba6\"}", + "request": "query getBlock($hash :Bytes32!) { block(hash:$hash) { number } }", + "response": { + "data": { + "block": { + "number": 30 + } + } + }, + "statusCode": 200 +} \ No newline at end of file diff --git a/ethereum/api/src/test/resources/org/hyperledger/besu/ethereum/api/graphql/graphql_variable_long.json b/ethereum/api/src/test/resources/org/hyperledger/besu/ethereum/api/graphql/graphql_variable_long.json new file mode 100644 index 00000000000..4f1b8c5e264 --- /dev/null +++ b/ethereum/api/src/test/resources/org/hyperledger/besu/ethereum/api/graphql/graphql_variable_long.json @@ -0,0 +1,17 @@ +{ + "variables": "{ \"block1\": \"0x1d\", \"block2\": \"0x1e\"}", + "request": "query getBlockRange($block1 :Long, $block2: Long) { blocks(from: $block1, to: $block2) { hash } }", + "response": { + "data": { + "blocks": [ + { + "hash": "0xf8cfa377bd766cdf22edb388dd08cc149e85d24f2796678c835f3c54ab930803" + }, + { + "hash": "0xc8df1f061abb4d0c107b2b1a794ade8780b3120e681f723fe55a7be586d95ba6" + } + ] + } + }, + "statusCode": 200 +} \ No newline at end of file