def test_dispatch_to_response_pure_method_not_found():
assert dispatch_to_response_pure(
deserializer=default_deserializer,
validator=default_validator,
post_process=identity,
context=NOCONTEXT,
methods={},
request='{"jsonrpc": "2.0", "method": "non_existant", "id": 1}',
) == Left(
ErrorResponse(ERROR_METHOD_NOT_FOUND, "Method not found", "non_existant", 1)
)
def test_dispatch_to_response_pure_notification_method_not_found():
assert (
dispatch_to_response_pure(
deserializer=default_deserializer,
validator=default_validator,
post_process=identity,
context=NOCONTEXT,
methods={},
request='{"jsonrpc": "2.0", "method": "non_existant"}',
)
== None
)
def test_examples_notification():
response = dispatch_to_response_pure(
methods={"update": lambda: None, "foobar": lambda: None},
context=NOCONTEXT,
validator=default_validator,
post_process=identity,
deserializer=default_deserializer,
request='{"jsonrpc": "2.0", "method": "update", "params": [1, 2, 3, 4, 5]}',
)
assert response is None
# Second example
response = dispatch_to_response_pure(
methods={"update": lambda: None, "foobar": lambda: None},
context=NOCONTEXT,
validator=default_validator,
post_process=identity,
deserializer=default_deserializer,
request='{"jsonrpc": "2.0", "method": "foobar"}',
)
assert response is None
def test_dispatch_to_response_pure():
assert (
dispatch_to_response_pure(
deserializer=default_deserializer,
validator=default_validator,
post_process=identity,
context=NOCONTEXT,
methods={"ping": ping},
request='{"jsonrpc": "2.0", "method": "ping", "id": 1}',
)
== Right(SuccessResponse("pong", 1))
)
def test_dispatch_to_response_pure_internal_error():
def foo():
raise ValueError("foo")
assert (
dispatch_to_response_pure(
deserializer=default_deserializer,
validator=default_validator,
post_process=identity,
context=NOCONTEXT,
methods={"foo": foo},
request='{"jsonrpc": "2.0", "method": "foo", "id": 1}',
)
== Left(ErrorResponse(ERROR_INTERNAL_ERROR, "Internal error", "foo", 1))
)
def test_dispatch_to_response_pure_notification_internal_error():
def foo(bar):
raise ValueError
assert (
dispatch_to_response_pure(
deserializer=default_deserializer,
validator=default_validator,
post_process=identity,
context=NOCONTEXT,
methods={"foo": foo},
request='{"jsonrpc": "2.0", "method": "foo"}',
)
== None
)
def test_examples_positionals():
def subtract(minuend, subtrahend):
return Success(minuend - subtrahend)
response = dispatch_to_response_pure(
methods={"subtract": subtract},
context=NOCONTEXT,
validator=default_validator,
post_process=identity,
deserializer=default_deserializer,
request='{"jsonrpc": "2.0", "method": "subtract", "params": [42, 23], "id": 1}',
)
assert response == Right(SuccessResponse(19, 1))
# Second example
response = dispatch_to_response_pure(
methods={"subtract": subtract},
context=NOCONTEXT,
validator=default_validator,
post_process=identity,
deserializer=default_deserializer,
request='{"jsonrpc": "2.0", "method": "subtract", "params": [23, 42], "id": 2}',
)
assert response == Right(SuccessResponse(-19, 2))
def test_examples_nameds():
def subtract(**kwargs):
return Success(kwargs["minuend"] - kwargs["subtrahend"])
response = dispatch_to_response_pure(
methods={"subtract": subtract},
context=NOCONTEXT,
validator=default_validator,
post_process=identity,
deserializer=default_deserializer,
request='{"jsonrpc": "2.0", "method": "subtract", "params": {"subtrahend": 23, "minuend": 42}, "id": 3}',
)
assert response == Right(SuccessResponse(19, 3))
# Second example
response = dispatch_to_response_pure(
methods={"subtract": subtract},
context=NOCONTEXT,
validator=default_validator,
post_process=identity,
deserializer=default_deserializer,
request='{"jsonrpc": "2.0", "method": "subtract", "params": {"minuend": 42, "subtrahend": 23}, "id": 4}',
)
assert response == Right(SuccessResponse(19, 4))
def test_dispatch_to_response_pure_notification_invalid_params_auto():
def foo(colour: str, size: str):
return Success()
assert (
dispatch_to_response_pure(
deserializer=default_deserializer,
validator=default_validator,
post_process=identity,
context=NOCONTEXT,
methods={"foo": foo},
request='{"jsonrpc": "2.0", "method": "foo", "params": {"colour":"blue"}}',
)
== None
)
def test_dispatch_to_response_pure_notification_server_error(*_):
def foo():
return Success()
assert (
dispatch_to_response_pure(
deserializer=default_deserializer,
validator=default_validator,
post_process=identity,
context=NOCONTEXT,
methods={"foo": foo},
request='{"jsonrpc": "2.0", "method": "foo"}',
)
== Left(ErrorResponse(ERROR_SERVER_ERROR, "Server error", "foo", None))
)
def test_dispatch_to_response_pure_invalid_params_explicitly_returned():
def foo(colour: str) -> Result:
if colour not in ("orange", "red", "yellow"):
return InvalidParams()
assert (
dispatch_to_response_pure(
deserializer=default_deserializer,
validator=default_validator,
post_process=identity,
context=NOCONTEXT,
methods={"foo": foo},
request='{"jsonrpc": "2.0", "method": "foo", "params": ["blue"], "id": 1}',
)
== Left(ErrorResponse(ERROR_INVALID_PARAMS, "Invalid params", NODATA, 1))
)
def test_dispatch_to_response_pure_invalid_params_notification_explicitly_returned():
def foo(colour: str) -> Result:
if colour not in ("orange", "red", "yellow"):
return InvalidParams()
assert (
dispatch_to_response_pure(
deserializer=default_deserializer,
validator=default_validator,
post_process=identity,
context=NOCONTEXT,
methods={"foo": foo},
request='{"jsonrpc": "2.0", "method": "foo", "params": ["blue"]}',
)
== None
)
def test_examples_invalid_json():
response = dispatch_to_response_pure(
methods={"ping": ping},
context=NOCONTEXT,
validator=default_validator,
post_process=identity,
deserializer=default_deserializer,
request='[{"jsonrpc": "2.0", "method": "sum", "params": [1,2,4], "id": "1"}, {"jsonrpc": "2.0", "method"]',
)
assert response == Left(
ErrorResponse(
ERROR_PARSE_ERROR,
"Parse error",
"Expecting ':' delimiter: line 1 column 96 (char 95)",
None,
)
)
def test_dispatch_to_response_pure_notification_raising_exception():
"""Allow raising an exception to return an error."""
def raise_exception():
raise JsonRpcError(code=0, message="foo", data="bar")
assert (
dispatch_to_response_pure(
deserializer=default_deserializer,
validator=default_validator,
post_process=identity,
context=NOCONTEXT,
methods={"raise_exception": raise_exception},
request='{"jsonrpc": "2.0", "method": "raise_exception"}',
)
== None
)
def test_dispatch_to_response_pure_notification_invalid_result():
"""Methods should return a Result, otherwise we get an Internal Error response."""
def not_a_result():
return None
assert (
dispatch_to_response_pure(
deserializer=default_deserializer,
validator=default_validator,
post_process=identity,
context=NOCONTEXT,
methods={"not_a_result": not_a_result},
request='{"jsonrpc": "2.0", "method": "not_a_result"}',
)
== None
)
def test_dispatch_to_response_pure_notification_invalid_request():
"""Invalid JSON-RPC, must return an error. (impossible to determine if notification)"""
assert dispatch_to_response_pure(
deserializer=default_deserializer,
validator=default_validator,
post_process=identity,
context=NOCONTEXT,
methods={"ping": ping},
request="{}",
) == Left(
ErrorResponse(
ERROR_INVALID_REQUEST,
"Invalid request",
"The request failed schema validation",
None,
)
)
def test_dispatch_to_response_pure_notification_parse_error():
"""Unable to parse, must return an error"""
assert dispatch_to_response_pure(
deserializer=default_deserializer,
validator=default_validator,
post_process=identity,
context=NOCONTEXT,
methods={"ping": ping},
request="{",
) == Left(
ErrorResponse(
ERROR_PARSE_ERROR,
"Parse error",
"Expecting property name enclosed in double quotes: line 1 column 2 (char 1)",
None,
)
)
def test_examples_empty_array():
# This is an invalid JSON-RPC request, should return an error.
response = dispatch_to_response_pure(
request="[]",
methods={"ping": ping},
context=NOCONTEXT,
validator=default_validator,
post_process=identity,
deserializer=default_deserializer,
)
assert response == Left(
ErrorResponse(
ERROR_INVALID_REQUEST,
"Invalid request",
"The request failed schema validation",
None,
)
)
def test_dispatch_to_response_pure_invalid_params_auto():
def foo(colour: str, size: str):
return Success()
assert dispatch_to_response_pure(
deserializer=default_deserializer,
validator=default_validator,
post_process=identity,
context=NOCONTEXT,
methods={"foo": foo},
request='{"jsonrpc": "2.0", "method": "foo", "params": {"colour":"blue"}, "id": 1}',
) == Left(
ErrorResponse(
ERROR_INVALID_PARAMS,
"Invalid params",
"missing a required argument: 'size'",
1,
)
)
def test_examples_multiple_invalid_jsonrpc():
"""
We break the spec here, by not validating each request in the batch individually.
The examples are expecting a batch response full of error responses.
"""
response = dispatch_to_response_pure(
deserializer=default_deserializer,
validator=default_validator,
post_process=identity,
context=NOCONTEXT,
methods={"ping": ping},
request="[1, 2, 3]",
)
assert response == Left(
ErrorResponse(
ERROR_INVALID_REQUEST,
"Invalid request",
"The request failed schema validation",
None,
)
)
def test_dispatch_to_response_pure_invalid_result():
"""Methods should return a Result, otherwise we get an Internal Error response."""
def not_a_result():
return None
assert dispatch_to_response_pure(
deserializer=default_deserializer,
validator=default_validator,
post_process=identity,
context=NOCONTEXT,
methods={"not_a_result": not_a_result},
request='{"jsonrpc": "2.0", "method": "not_a_result", "id": 1}',
) == Left(
ErrorResponse(
ERROR_INTERNAL_ERROR,
"Internal error",
"The method did not return a valid Result (returned None)",
1,
)
)
def test_examples_mixed_requests_and_notifications():
"""
We break the spec here. The examples put an invalid jsonrpc request in the
mix here. but it's removed to test the rest, because we're not validating
each request individually. Any invalid jsonrpc will respond with a single
error message.
The spec example includes this which invalidates the entire request:
{"foo": "boo"},
"""
methods = {
"sum": lambda *args: Right(SuccessResult(sum(args))),
"notify_hello": lambda *args: Right(SuccessResult(19)),
"subtract": lambda *args: Right(SuccessResult(args[0] - sum(args[1:]))),
"get_data": lambda: Right(SuccessResult(["hello", 5])),
}
requests = json.dumps(
[
{"jsonrpc": "2.0", "method": "sum", "params": [1, 2, 4], "id": "1"},
{"jsonrpc": "2.0", "method": "notify_hello", "params": [7]},
{"jsonrpc": "2.0", "method": "subtract", "params": [42, 23], "id": "2"},
{
"jsonrpc": "2.0",
"method": "foo.get",
"params": {"name": "myself"},
"id": "5",
},
{"jsonrpc": "2.0", "method": "get_data", "id": "9"},
]
)
response = dispatch_to_response_pure(
deserializer=default_deserializer,
validator=default_validator,
post_process=identity,
context=NOCONTEXT,
methods=methods,
request=requests,
)
expected = [
Right(
SuccessResponse(result=7, id="1")
), # {"jsonrpc": "2.0", "result": 7, "id": "1"},
Right(
SuccessResponse(result=19, id="2")
), # {"jsonrpc": "2.0", "result": 19, "id": "2"},
Left(
ErrorResponse(
code=-32601, message="Method not found", data="foo.get", id="5"
)
),
# {
# "jsonrpc": "2.0",
# "error": {"code": -32601, "message": "Method not found", "data": "foo.get"},
# "id": "5",
# },
Right(
SuccessResponse(result=["hello", 5], id="9")
), # {"jsonrpc": "2.0", "result": ["hello", 5], "id": "9"},
]
# assert isinstance(response, Iterable)
for r in response:
assert r in expected
