def test_method_validation_not_str(self):
self.request_params.update({"method": []})
with self.assertRaises(JSONRPCInvalidRequestException):
JSONRPCSingleRequest(self.request_params)
self.request_params.update({"method": {}})
with self.assertRaises(JSONRPCInvalidRequestException):
JSONRPCSingleRequest(self.request_params)
def test_incorrect_empty_request(self):
request = {}
with self.assertRaises(JSONRPCInvalidRequestException):
JSONRPCSingleRequest(json.dumps(request))
with self.assertRaises(JSONRPCInvalidRequestException):
JSONRPCSingleRequest(request)
def test_id_validation_incorrect(self):
self.request_params.update({"id": []})
with self.assertRaises(JSONRPCInvalidRequestException):
JSONRPCSingleRequest(self.request_params)
self.request_params.update({"id": ()})
with self.assertRaises(JSONRPCInvalidRequestException):
JSONRPCSingleRequest(self.request_params)
def test_batch_request(self):
request = JSONRPCBatchRequest([
JSONRPCSingleRequest({"method": "devide", "params": {"num": 1, "denom": 2}, "id": 1, "jsonrpc": "2.0"}),
JSONRPCSingleRequest({"method": "devide", "params": {"num": 3, "denom": 2}, "id": 2, "jsonrpc": "2.0"}),
])
self.assertEqual(json.loads(request.json), [
{"method": "devide", "params": {"num": 1, "denom": 2}, "id": 1, "jsonrpc": "2.0"},
{"method": "devide", "params": {"num": 3, "denom": 2}, "id": 2, "jsonrpc": "2.0"},
])
self.assertTrue(request)
def test_response_iterator(self):
requests = [
JSONRPCSingleRequest({"method": "devide", "params": {"num": 1, "denom": 2}, "id": 1, "jsonrpc": "2.0"}),
JSONRPCSingleRequest({"method": "devide", "params": {"num": 3, "denom": 2}, "id": 2, "jsonrpc": "2.0"}),
]
batch = JSONRPCBatchRequest(requests)
for request in batch:
self.assertIsInstance(request, JSONRPCSingleRequest)
self.assertIsInstance(batch, JSONRPCBatchRequest)
self.assertEqual(request.method, "devide")
def test_set_unset_notification_keep_id(self):
r = JSONRPCSingleRequest({"jsonrpc": "2.0", "method": "add", "id": 0})
r.is_notification = True
self.assertTrue(r.is_notification)
self.assertNotIn("id", r.data)
r.is_notification = False
self.assertFalse(r.is_notification)
self.assertTrue("id" in r.data)
self.assertEqual(r.data["id"], 0)
def test_data_setter(self):
request = JSONRPCSingleRequest(self.request_params)
with self.assertRaises(JSONRPCMultipleRequestException):
request.data = []
with self.assertRaises(JSONRPCParseException):
request.data = ""
with self.assertRaises(JSONRPCInvalidRequestException):
request.data = None
def test_incorrect_multiple_json(self):
lst = [
{"method": "devide", "params": {"num": 1, "denom": 2}, "id": 1, "jsonrpc": "2.0"},
{"method": "devide", "params": {"num": 3, "denom": 2}, "id": 2, "jsonrpc": "2.0"}
]
with self.assertRaises(JSONRPCMultipleRequestException):
JSONRPCSingleRequest(json.dumps(lst))
with self.assertRaises(JSONRPCMultipleRequestException):
JSONRPCSingleRequest(lst)
def test_method_validation_str_rpc_prefix(self):
""" Test method SHOULD NOT starts with rpc. """
self.request_params.update({"method": "rpc."})
with self.assertRaises(JSONRPCInvalidRequestException):
JSONRPCSingleRequest(self.request_params)
self.request_params.update({"method": "rpc.test"})
with self.assertRaises(JSONRPCInvalidRequestException):
JSONRPCSingleRequest(self.request_params)
self.request_params.update({"method": "rpccorrect"})
JSONRPCSingleRequest(self.request_params)
self.request_params.update({"method": "rpc"})
JSONRPCSingleRequest(self.request_params)
def test_response_iterator(self):
request_1 = JSONRPCSingleRequest({"method": "add", "params": [1, 2], "jsonrpc": "2.0", "id": 1})
request_2 = JSONRPCSingleRequest({"method": "mul", "params": [7, 3], "jsonrpc": "2.0", "id": 2})
request_3 = JSONRPCSingleRequest({"method": "ping", "jsonrpc": "2.0"})
result_1 = 2
result_2 = 21
result_3 = "pong"
responses = JSONRPCBatchResponse([
JSONRPCSingleResponse(result_1, request=request_1),
JSONRPCSingleResponse(result_2, request=request_2),
JSONRPCSingleResponse(result_3, request=request_3)
])
for response in responses:
self.assertIsInstance(response, JSONRPCSingleResponse)
def test_from_json_invalid_request_method(self):
str_json = json.dumps({
"jsonrpc": "2.0",
})
with self.assertRaises(JSONRPCInvalidRequestException):
JSONRPCSingleRequest(str_json)
def test_serialize_method_1(self):
r = JSONRPCSingleRequest({"jsonrpc": "2.0", "method": "add"})
self.assertEqual(
{
"jsonrpc": "2.0",
"method": "add",
}, json.loads(r.json))
def test_data_id_3(self):
r = JSONRPCSingleRequest({"jsonrpc": "2.0", "method": "add", "id": "id"})
self.assertEqual(r.data, {
"jsonrpc": "2.0",
"method": "add",
"id": "id",
})
def handle(self, request_string, dispatcher):
"""
Method brings syntactic sugar into library.
Given dispatcher it handles request (both single and batch) and handles errors.
Request could be handled in parallel, it is server responsibility.
:param request_string: JSON string.
Will be converted into JSONRPCSingleRequest or JSONRPCBatchRequest
:type request_string: str
:type dispatcher: Dispatcher or dict
:rtype: JSONRPCSingleResponse or JSONRPCBatchResponse
"""
try:
data = self.deserialize(request_string)
if isinstance(data, list):
request = JSONRPCBatchRequest(
data, serialize_hook=self.serialize_hook)
elif isinstance(data, dict):
request = JSONRPCSingleRequest(
data, serialize_hook=self.serialize_hook)
else:
raise JSONRPCInvalidRequestException
except (TypeError, ValueError, JSONRPCParseException):
return JSONRPCParseError().as_response()
except JSONRPCInvalidRequestException:
return JSONRPCInvalidRequest().as_response()
else:
return request.process(dispatcher)
def test_data_params_6(self):
r = JSONRPCSingleRequest({"jsonrpc": "2.0", "method": "add", "params": {"a": 0}, "id": 1})
self.assertEqual(r.data, {
"jsonrpc": "2.0",
"method": "add",
"params": {"a": 0},
"id": 1,
})
def test_from_json_invalid_request_extra_data(self):
str_json = json.dumps({
"jsonrpc": "2.0",
"method": "add",
"is_notification": True,
})
with self.assertRaises(JSONRPCInvalidRequestException):
JSONRPCSingleRequest(str_json)
def test_batch_response(self):
response = JSONRPCBatchResponse([
JSONRPCSingleResponse("pong", request=JSONRPCSingleRequest({"method": "ping", "jsonrpc": "2.0", "id": 1})),
JSONRPCSingleResponse({"code": 0, "message": ""}, error=True),
])
self.assertEqual(json.loads(response.json), [
{"result": "pong", "id": 1, "jsonrpc": "2.0"},
{"error": {"code": 0, "message": ""}, "id": None, "jsonrpc": "2.0"},
])
def test_server_error(self):
request = JSONRPCSingleRequest({'jsonrpc': '2.0', 'method': 'error', 'id': 0})
response = self.manager.handle(request.json, self.dispatcher)
self.assertIsInstance(response, JSONRPCSingleResponse)
self.assertEqual(response.error["message"], "Server error")
self.assertEqual(response.error["code"], -32000)
self.assertEqual(response.error["data"], {
"type": "Exception",
"message": 'error_explanation',
})
def test_serialize_params_5(self):
r = JSONRPCSingleRequest({"jsonrpc": "2.0", "method": "add", "params": {"a": 0}, "id": 1})
self.assertEqual(
{
"jsonrpc": "2.0",
"method": "add",
"params": {"a": 0},
"id": 1,
},
json.loads(r.json)
)
def test_from_json_request_no_params(self):
str_json = json.dumps({
"method": "add",
"jsonrpc": "2.0",
})
request = JSONRPCSingleRequest(str_json)
self.assertIsInstance(request, JSONRPCSingleRequest)
self.assertEqual(request.method, "add")
self.assertEqual(request.params, None)
self.assertEqual(request.id, None)
self.assertTrue(request.is_notification)
def test_from_json_batch_one(self):
req_data = {"method": "add", "params": [1, 2], "jsonrpc": "2.0", "id": 1}
request = JSONRPCSingleRequest(req_data)
requests = JSONRPCBatchRequest(request)
self.assertIsInstance(requests, JSONRPCBatchRequest)
self.assertEqual(len(requests), 1)
r = requests[0]
self.assertIsInstance(r, JSONRPCSingleRequest)
self.assertEqual(r.method, "add")
self.assertEqual(r.params, [1, 2])
self.assertEqual(r.id, 1)
self.assertFalse(r.is_notification)
def test_from_json_request(self):
str_json = json.dumps({
"method": "add",
"params": [0, 1],
"jsonrpc": "2.0",
"id": "id",
})
request = JSONRPCSingleRequest(str_json)
self.assertIsInstance(request, JSONRPCSingleRequest)
self.assertEqual(request.method, "add")
self.assertEqual(request.params, [0, 1])
self.assertEqual(request.id, "id")
self.assertFalse(request.is_notification)
def test_batch_response_from_single(self):
request = JSONRPCSingleRequest({"method": "ping", "jsonrpc": "2.0", "id": 1})
result = "pong"
response = JSONRPCSingleResponse(result, request=request)
batch_with_list = JSONRPCBatchResponse([response])
batch_without_list = JSONRPCBatchResponse(response)
self.assertTrue(isjsonequal(batch_with_list.json, batch_without_list.json))
iter(batch_with_list)
iter(batch_without_list)
iter(response)
self.assertEqual(len(batch_with_list), 1)
self.assertEqual(len(batch_without_list), 1)
self.assertTrue(isjsonequal(response.json, batch_with_list[0].json))
self.assertTrue(isjsonequal(response.json, batch_without_list[0].json))
def test_is_notification(self):
r = JSONRPCSingleRequest({"jsonrpc": "2.0", "method": "add"})
self.assertTrue(r.is_notification)
r = JSONRPCSingleRequest({"jsonrpc": "2.0", "method": "add", "id": 1})
self.assertFalse(r.is_notification)
r = JSONRPCSingleRequest({"jsonrpc": "2.0", "method": "add", "id": 'null'})
self.assertFalse(r.is_notification)
r = JSONRPCSingleRequest({"jsonrpc": "2.0", "method": "add", "id": 0})
self.assertFalse(r.is_notification)
r = JSONRPCSingleRequest({"jsonrpc": "2.0", "method": "add", "id": 1})
r.is_notification = True
self.assertTrue(r.is_notification)
self.assertNotIn("id", r.data)
r = JSONRPCSingleRequest({"jsonrpc": "2.0", "method": "add", "id": 0})
r.is_notification = True
self.assertTrue(r.is_notification)
self.assertNotIn("id", r.data)
def test_request_args(self):
req_data = {"jsonrpc": "2.0", "method": "add", "id": 1}
self.assertEqual(JSONRPCSingleRequest(req_data).args, ())
self.assertEqual(JSONRPCSingleRequest(dict(req_data, params=[])).args, ())
self.assertEqual(JSONRPCSingleRequest(dict(req_data, params={"a": 1})).args, ())
self.assertEqual(JSONRPCSingleRequest(dict(req_data, params=[1, 2])).args, (1, 2))
def test_params_validation_incorrect(self):
self.request_params.update({"params": "str"})
with self.assertRaises(JSONRPCInvalidRequestException):
JSONRPCSingleRequest(self.request_params)
def test_params_validation_none(self):
self.request_params.update({"params": None})
with self.assertRaises(JSONRPCInvalidRequestException):
JSONRPCSingleRequest(self.request_params)
def test_params_validation_dict(self):
self.request_params.update({"params": {}})
JSONRPCSingleRequest(self.request_params)
self.request_params.update({"params": {"a": 0}})
JSONRPCSingleRequest(self.request_params)
def test_params_validation_tuple(self):
self.request_params.update({"params": ()})
JSONRPCSingleRequest(self.request_params)
self.request_params.update({"params": tuple([0])})
JSONRPCSingleRequest(self.request_params)
def test_params_validation_list(self):
self.request_params.update({"params": []})
JSONRPCSingleRequest(self.request_params)
self.request_params.update({"params": [0]})
JSONRPCSingleRequest(self.request_params)
def setUpClass(cls):
cls.request = JSONRPCSingleRequest({"method": "add", "params": [1, 2], "jsonrpc": "2.0", "id": 1})
cls.result = 3
cls.error_data = {"code": 1, "message": "error"}