def test_add_static_method():
class FooClass:
@staticmethod
def foo():
return "bar"
assert Methods(FooClass.foo).items["foo"] is FooClass.foo
def test_add_static_method_custom_name():
class FooClass:
@staticmethod
def foo():
return "bar"
assert Methods(custom=FooClass.foo).items["custom"] == FooClass.foo
def test_safe_call_success_response():
response = safe_call(Request(method="ping", id=1),
Methods(ping),
debug=True)
assert isinstance(response, SuccessResponse)
assert response.result == "pong"
assert response.id == 1
def test_dispatch_pure_invalid_json():
"""Unable to parse, must return an error"""
response = dispatch_pure("{",
Methods(ping),
convert_camel_case=False,
context=NOCONTEXT,
debug=True)
assert isinstance(response, InvalidJSONResponse)
def test_dispatch_pure_invalid_jsonrpc():
"""Invalid JSON-RPC, must return an error. (impossible to determine if notification)"""
response = dispatch_pure("{}",
Methods(ping),
convert_camel_case=False,
context=NOCONTEXT,
debug=True)
assert isinstance(response, InvalidJSONRPCResponse)
def test_add_function_via_decorator():
methods = Methods()
@methods.add
def foo():
pass
assert methods.items["foo"] is foo
def test_dispatch_pure_notification():
response = dispatch_pure(
'{"jsonrpc": "2.0", "method": "ping"}',
Methods(ping),
convert_camel_case=False,
context=NOCONTEXT,
debug=True,
)
assert isinstance(response, NotificationResponse)
def test_dispatch_pure_notification_invalid_jsonrpc():
response = dispatch_pure(
'{"jsonrpc": "0", "method": "notify"}',
Methods(ping),
convert_camel_case=False,
context=NOCONTEXT,
debug=True,
)
assert isinstance(response, ErrorResponse)
def test_call_requests_with_context():
def ping_with_context(context=None):
assert context is sentinel.context
call_requests(
Request("ping_with_context", convert_camel_case=False),
Methods(ping_with_context),
debug=True,
)
def test_get():
def cat():
pass
def dog():
pass
methods = Methods(cat, dog)
assert methods.items["cat"] == cat
assert methods.items["dog"] == dog
def test_add_static_method_via_decorator():
methods = Methods()
class FooClass:
@staticmethod
@methods.add
def foo():
return "bar"
assert methods.items["foo"] is FooClass.foo
def test_dispatch_pure_request():
response = dispatch_pure(
'{"jsonrpc": "2.0", "method": "ping", "id": 1}',
Methods(ping),
convert_camel_case=False,
context=NOCONTEXT,
debug=True,
)
assert isinstance(response, SuccessResponse)
assert response.result == "pong"
assert response.id == 1
def test_dispatch_pure_invalid_params():
def foo(colour):
assert colour in ("orange", "red", "yellow"), "Invalid colour"
response = dispatch_pure(
'{"jsonrpc": "2.0", "method": "foo", "params": ["blue"], "id": 1}',
Methods(foo),
convert_camel_case=False,
context=NOCONTEXT,
debug=True,
)
assert isinstance(response, InvalidParamsResponse)
def test_examples_empty_array():
# This is an invalid JSON-RPC request, should return an error.
response = dispatch_pure("[]",
Methods(ping),
convert_camel_case=False,
context=NOCONTEXT,
debug=True)
assert isinstance(response, ErrorResponse)
assert (
str(response) ==
'{"jsonrpc": "2.0", "error": {"code": -32600, "message": "Invalid JSON-RPC", "data": null}, "id": null}'
)
def test_examples_invalid_json():
response = dispatch_pure(
'[{"jsonrpc": "2.0", "method": "sum", "params": [1,2,4], "id": "1"}, {"jsonrpc": "2.0", "method"]',
Methods(ping),
convert_camel_case=False,
context=NOCONTEXT,
debug=True,
)
assert isinstance(response, ErrorResponse)
assert (
str(response) ==
'{"jsonrpc": "2.0", "error": {"code": -32700, "message": "Invalid JSON", "data": "Expecting \':\' delimiter: line 1 column 96 (char 95)"}, "id": null}'
)
def test_add_instance_method_custom_name():
class Foo:
def __init__(self, name):
self.name = name
def get_name(self):
return self.name
obj1 = Foo("a")
obj2 = Foo("b")
methods = Methods(custom1=obj1.get_name, custom2=obj2.get_name)
# Can't use assertIs, so check the outcome is as expected
assert methods.items["custom1"].__call__() == "a"
assert methods.items["custom2"].__call__() == "b"
def test_examples_nameds():
def subtract(**kwargs):
return kwargs["minuend"] - kwargs["subtrahend"]
response = dispatch_pure(
'{"jsonrpc": "2.0", "method": "subtract", "params": {"subtrahend": 23, "minuend": 42}, "id": 3}',
Methods(subtract),
convert_camel_case=False,
context=NOCONTEXT,
debug=True,
)
assert isinstance(response, SuccessResponse)
assert response.result == 19
# Second example
response = dispatch_pure(
'{"jsonrpc": "2.0", "method": "subtract", "params": {"minuend": 42, "subtrahend": 23}, "id": 4}',
Methods(subtract),
convert_camel_case=False,
context=NOCONTEXT,
debug=True,
)
assert isinstance(response, SuccessResponse)
assert response.result == 19
def test_examples_invalid_jsonrpc_batch():
"""
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_pure("[1]",
Methods(ping),
convert_camel_case=False,
context=NOCONTEXT,
debug=True)
assert isinstance(response, InvalidJSONRPCResponse)
assert (
str(response) ==
'{"jsonrpc": "2.0", "error": {"code": -32600, "message": "Invalid JSON-RPC", "data": null}, "id": null}'
)
def test_examples_positionals():
def subtract(minuend, subtrahend):
return minuend - subtrahend
response = dispatch_pure(
'{"jsonrpc": "2.0", "method": "subtract", "params": [42, 23], "id": 1}',
Methods(subtract),
convert_camel_case=False,
context=NOCONTEXT,
debug=True,
)
assert isinstance(response, SuccessResponse)
assert response.result == 19
# Second example
response = dispatch_pure(
'{"jsonrpc": "2.0", "method": "subtract", "params": [23, 42], "id": 2}',
Methods(subtract),
convert_camel_case=False,
context=NOCONTEXT,
debug=True,
)
assert isinstance(response, SuccessResponse)
assert response.result == -19
def test_call_requests_batch_all_notifications():
"""Should return a BatchResponse response, an empty list"""
response = call_requests(
{
Request(**{
"jsonrpc": "2.0",
"method": "notify_sum",
"params": [1, 2, 4]
}),
Request(**{
"jsonrpc": "2.0",
"method": "notify_hello",
"params": [7]
}),
},
Methods(ping),
debug=True,
)
assert str(response) == ""
def test_safe_call_invalid_args():
response = safe_call(Request(method="ping", params=[1], id=1),
Methods(ping),
debug=True)
assert isinstance(response, InvalidParamsResponse)
def test_safe_call_method_not_found():
response = safe_call(Request(method="nonexistant", id=1),
Methods(ping),
debug=True)
assert isinstance(response, MethodNotFoundResponse)
def test_safe_call_notification_failure():
def fail():
raise ValueError()
response = safe_call(Request(method="foo"), Methods(fail), debug=True)
assert isinstance(response, NotificationResponse)
def test_safe_call_notification():
response = safe_call(Request(method="ping"), Methods(ping), debug=True)
assert isinstance(response, NotificationResponse)
def test_add_partial_no_name():
six = partial(lambda x: x + 1, 5)
methods = Methods()
with pytest.raises(AttributeError):
methods.add(six) # Partial has no __name__ !
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 = Methods(
**{
"sum": lambda *args: sum(args),
"notify_hello": lambda *args: 19,
"subtract": lambda *args: args[0] - sum(args[1:]),
"get_data": lambda: ["hello", 5],
})
requests = serialize([
{
"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_pure(requests,
methods,
convert_camel_case=False,
context=NOCONTEXT,
debug=True)
expected = [
{
"jsonrpc": "2.0",
"result": 7,
"id": "1"
},
{
"jsonrpc": "2.0",
"result": 19,
"id": "2"
},
{
"jsonrpc": "2.0",
"error": {
"code": -32601,
"message": "Method not found",
"data": "foo.get"
},
"id": "5",
},
{
"jsonrpc": "2.0",
"result": ["hello", 5],
"id": "9"
},
]
assert isinstance(response, BatchResponse)
for r in response.deserialized():
assert r in expected
def test_add_partial_custom_name():
six = partial(lambda x: x + 1, 5)
assert Methods(six=six).items["six"] is six
def test_add_partial_renamed():
six = partial(lambda x: x + 1, 5)
six.__name__ = "six"
assert Methods(six).items["six"] is six
def test_dispatch_basic_logging():
response = dispatch(
'{"jsonrpc": "2.0", "method": "ping", "id": 1}',
Methods(ping),
basic_logging=True,
)
def test_dispatch():
response = dispatch('{"jsonrpc": "2.0", "method": "ping", "id": 1}',
Methods(ping))
assert response.result == "pong"