def test_request_batch_index(urn_test_request_dict):
jsonrpc_request, urn, url, ttl, timeout = urn_test_request_dict
dummy_request = make_request()
jefferson_request = jsonrpc_from_request(dummy_request, 0, jsonrpc_request)
assert jefferson_request.batch_index == 0
jefferson_request = jsonrpc_from_request(dummy_request, 1, jsonrpc_request)
assert jefferson_request.batch_index == 1
def test_upstream_id(urn_test_request_dict):
jsonrpc_request, urn, url, ttl, timeout = urn_test_request_dict
dummy_request = make_request()
jefferson_request = jsonrpc_from_request(dummy_request, 0, jsonrpc_request)
assert jefferson_request.upstream_id == 123
jefferson_request = jsonrpc_from_request(dummy_request, 1, jsonrpc_request)
assert jefferson_request.upstream_id == 124
def test_upstream_headers(urn_test_request_dict):
jsonrpc_request, urn, url, ttl, timeout = urn_test_request_dict
dummy_request = make_request()
jefferson_request = jsonrpc_from_request(dummy_request, 0, jsonrpc_request)
assert jefferson_request.upstream_headers == {
'x-jefferson-request-id': '123',
'x-amzn-trace-id': '123'
}
dummy_request.headers['x-amzn-trace-id'] = '1'
jefferson_request = jsonrpc_from_request(dummy_request, 0, jsonrpc_request)
assert jefferson_request.upstream_headers == {
'x-jefferson-request-id': '123',
'x-amzn-trace-id': '1'
}
async def test_cache_group_cache_batch_jsonrpc_responses():
batch_req = [jsonrpc_from_request(dummy_request, _id, {
"id": _id, "jsonrpc": "2.0", "method": "get_block",
"params": [_id]
}) for _id in range(1, 10)]
batch_resp = [{'id': _id, "jsonrpc": "2.0", 'result': {
"previous": "0000000000000000000000000000000000000000",
"timestamp": "2018-09-04T16:36:27",
"witness": "dpay",
"transaction_merkle_root": "0000000000000000000000000000000000000000",
"extensions": [],
"witness_signature": "201522e89ede4eea643486772bb7cf5fd59224f0de226840124651dcb7a22251d772e1a8a953d7218eddf83618351f33ec401007713070b435253d44a3ad937db2",
"transactions": [],
"block_id": "000000011b5056ef5b610531031204f173aef7a8",
"signing_key": "DWB88FC9nDFczSTfVxrzHvVe8ZuvajLHKikfJYWiKkNvrUebBovzF",
"transaction_ids": []}} for _id in range(1, 10)]
caches = [
CacheGroupItem(build_mocked_cache(), True, True, SpeedTier.FAST),
CacheGroupItem(build_mocked_cache(), True, True, SpeedTier.FAST),
CacheGroupItem(build_mocked_cache(), True, True, SpeedTier.FAST)
]
cache_group = CacheGroup(caches)
keys = [jsonrpc_cache_key(req) for req in batch_req]
await cache_group.set('last_irreversible_block_num', 15_000_000, 180)
await cache_group.cache_batch_jsonrpc_response(batch_req, batch_resp)
for i, key in enumerate(keys):
assert cache_group._memory_cache.gets(key) == batch_resp[i]
assert await caches[0].cache.get(key) == batch_resp[i]
assert await caches[1].cache.get(key) == batch_resp[i]
assert await caches[2].cache.get(key) == batch_resp[i]
assert await cache_group.get(key) == batch_resp[i]
def upstream_request(urn_test_request_dict):
jsonrpc_request, urn, url, ttl, timeout = urn_test_request_dict
dummy_request = make_request()
jefferson_request = jsonrpc_from_request(dummy_request, 0, jsonrpc_request)
cpy = deepcopy(jefferson_request)
cpy['id'] = 123456789012345
assert jefferson_request.to_upstream_request(as_json=False) == cpy
assert jefferson_request.to_upstream_request() == ujson.dumps(
cpy, ensure_ascii=False)
cpy = deepcopy(jefferson_request)
cpy['id'] = 123456789012346
jefferson_request = jsonrpc_from_request(dummy_request, 1, cpy)
assert jefferson_request.to_upstream_request(as_json=False) == cpy
assert jefferson_request.to_upstream_request() == ujson.dumps(
cpy, ensure_ascii=False)
def jsonrpc(self) -> Optional[JrpcRequest]:
# ignore body and json if HTTP methos is not POST
if self.method != 'POST':
return None
if self._parsed_jsonrpc is _empty:
self._parsed_jsonrpc = None
from jefferson.errors import ParseError
from jefferson.errors import InvalidRequest
from jefferson.validators import validate_jsonrpc_request
try:
# raise ParseError for blank/empty body
if self.body is _empty:
raise ParseError(http_request=self)
# raise ParseError if parsing fails
try:
self._parsed_json = json_loads(self.body)
except Exception as e:
raise ParseError(http_request=self, exception=e)
# validate jsonrpc
jsonrpc_request = self._parsed_json
validate_jsonrpc_request(jsonrpc_request)
if isinstance(jsonrpc_request, dict):
self._parsed_jsonrpc = jsonrpc_from_request(
self, 0, jsonrpc_request)
self.is_single_jrpc = True
elif isinstance(jsonrpc_request, list):
self._parsed_jsonrpc = [
jsonrpc_from_request(self, batch_index, req)
for batch_index, req in enumerate(jsonrpc_request)
]
self.is_batch_jrpc = True
except ParseError as e:
raise e
except Exception as e:
raise InvalidRequest(http_request=self, exception=e)
return self._parsed_jsonrpc
async def test_cache_group_get_single_jsonrpc_response(
dpayd_request_and_response):
caches = [
CacheGroupItem(build_mocked_cache(), True, True, SpeedTier.FAST),
CacheGroupItem(build_mocked_cache(), True, True, SpeedTier.FAST),
CacheGroupItem(build_mocked_cache(), True, True, SpeedTier.FAST)
]
cache_group = CacheGroup(caches)
cache_group = CacheGroup(caches)
req, resp = dpayd_request_and_response
req = jsonrpc_from_request(dummy_request, 0, req)
resp['jsonrpc'] = '2.0'
key = jsonrpc_cache_key(req)
assert await cache_group.get(key) is None
await cache_group.set('last_irreversible_block_num', 15_000_000, 180)
await cache_group.cache_single_jsonrpc_response(req, resp)
assert await cache_group.get(key) == resp
assert await cache_group.get_single_jsonrpc_response(req) == resp
cache_group._memory_cache.clears()
assert await cache_group.get_single_jsonrpc_response(req) == resp
for cache_item in caches:
assert await cache_item.cache.get(key) == resp
def test_request_urn(urn_test_request_dict):
jsonrpc_request, urn, url, ttl, timeout = urn_test_request_dict
dummy_request = make_request()
jefferson_request = jsonrpc_from_request(dummy_request, 0, jsonrpc_request)
assert jefferson_request.urn == urn
def test_request_params(full_urn_test_request_dict):
jsonrpc_request, urn_parsed, urn, url, ttl, timeout = full_urn_test_request_dict
dummy_request = make_request()
jefferson_request = jsonrpc_from_request(dummy_request, 0, jsonrpc_request)
assert jefferson_request.params == jsonrpc_request.get('params', _empty)
def test_request_method(full_urn_test_request_dict):
jsonrpc_request, urn_parsed, urn, url, ttl, timeout = full_urn_test_request_dict
dummy_request = make_request()
jefferson_request = jsonrpc_from_request(dummy_request, 0, jsonrpc_request)
assert jefferson_request.method == jsonrpc_request['method']
def test_request_id(urn_test_request_dict):
jsonrpc_request, urn, url, ttl, timeout = urn_test_request_dict
dummy_request = make_request()
jefferson_request = jsonrpc_from_request(dummy_request, 0, jsonrpc_request)
assert jefferson_request.id == jsonrpc_request.get('id')
from jefferson.validators import is_valid_get_block_response
from jefferson.validators import is_valid_non_error_jefferson_response
from jefferson.validators import is_valid_non_error_single_jsonrpc_response
from jefferson.validators import is_valid_single_jsonrpc_response
from jefferson.validators import limit_broadcast_transaction_request
from jefferson.validators import limit_custom_json_op_length
from jefferson.validators import limit_custom_json_account
from jefferson.validators import is_broadcast_transaction_request
from jefferson.validators import validate_jsonrpc_request
from .conftest import make_request
dummy_request = make_request()
request = jsonrpc_from_request(dummy_request, 0, {
"id": "1", "jsonrpc": "2.0",
"method": "get_block", "params": [1000]
})
request2 = jsonrpc_from_request(dummy_request, 1, {
"id": "1", "jsonrpc": "2.0", "method": "call",
"params": ["database_api", "get_block", [1000]]
})
response = {
"id":1,
"result":{
"previous":"000003e70301334402ae97d8cef292a21247777f",
"timestamp":"2018-09-04T17:33:18",
"witness":"dpay",
"transaction_merkle_root":"0000000000000000000000000000000000000000",
"extensions":[],
def test_cache_group_is_complete_response(dpayd_request_and_response):
req, resp = dpayd_request_and_response
req = jsonrpc_from_request(dummy_request, 0, req)
assert CacheGroup.is_complete_response(req, resp) is True
def test_request_to_json(urn_test_request_dict):
jsonrpc_request, urn, url, ttl, timeout = urn_test_request_dict
dummy_request = make_request()
jefferson_request = jsonrpc_from_request(dummy_request, 0, jsonrpc_request)
assert ujson.loads(jefferson_request.json()) == jefferson_request.to_dict()
def test_is_broadcast_transaction_true_invalid(invalid_broadcast_transaction):
req = jsonrpc_from_request(dummy_request, 0,
invalid_broadcast_transaction)
assert is_broadcast_transaction_request(req) is True
def test_is_broadcast_transaction_false(dpayd_request_and_response):
req, resp = dpayd_request_and_response
req = jsonrpc_from_request(dummy_request, 0,
req)
assert is_broadcast_transaction_request(req) is False
def test_is_valid_jefferson_response_using_dpayd(dpayd_request_and_response):
req, resp = dpayd_request_and_response
req = jsonrpc_from_request(dummy_request, 0, req)
assert is_valid_non_error_jefferson_response(req, resp) is True
def test_is_valid_get_block_response(req, response, expected):
if not isinstance(req, JSONRPCRequest):
req = jsonrpc_from_request(dummy_request, 0, req)
assert is_valid_get_block_response(req, response) is expected
def test_is_get_block_header_request(req, expected):
if not isinstance(req, JSONRPCRequest):
req = jsonrpc_from_request(dummy_request, 0, req)
assert is_get_block_header_request(req) is expected
def test_request_upstream(urn_test_request_dict):
jsonrpc_request, urn, url, ttl, timeout = urn_test_request_dict
dummy_request = make_request()
jefferson_request = jsonrpc_from_request(dummy_request, 0, jsonrpc_request)
os.environ['JEFFERSON_ACCOUNT_TRANSFER_DPAYD_URL'] = 'account_transfer_url'
assert jefferson_request.upstream.url == url
def test_limit_broadcast_transaction_request(dpayd_request_and_response):
req, resp = dpayd_request_and_response
req = jsonrpc_from_request(dummy_request, 0, req)
limit_broadcast_transaction_request(req)
def test_cache_group_x_jefferson_cache_key(dpayd_request_and_response):
req, resp = dpayd_request_and_response
req = jsonrpc_from_request(dummy_request, 0, req)
batch_req = [req, req, req]
assert jsonrpc_cache_key(req) == CacheGroup.x_jefferson_cache_key(req)
assert CacheGroup.x_jefferson_cache_key(batch_req) == 'batch'
def test_valid_limit_broadcast_transaction_request(valid_broadcast_transaction):
req = jsonrpc_from_request(dummy_request, 0, valid_broadcast_transaction)
limit_broadcast_transaction_request(
req, limits=TEST_UPSTREAM_CONFIG['limits'])
def test_invalid_limit_broadcast_transaction_request(invalid_broadcast_transaction):
req = jsonrpc_from_request(dummy_request, 0, invalid_broadcast_transaction)
with pytest.raises(JsonRpcError):
limit_broadcast_transaction_request(
req, limits=TEST_UPSTREAM_CONFIG['limits'])
# -*- coding: utf-8 -*-
import pytest
from jefferson.cache.utils import jsonrpc_cache_key
from jefferson.request.jsonrpc import JSONRPCRequest
from .conftest import make_request
from jefferson.request.jsonrpc import from_http_request as jsonrpc_from_request
jrpc_req_1 = jsonrpc_from_request(make_request(), 0, {
"id": "1",
"jsonrpc": "2.0",
"method": "get_block",
"params": [1000]
})
jrpc_resp_1 = {
"id": 1,
"result": {
"previous": "000003e70301334402ae97d8cef292a21247777f",
"timestamp": "2018-09-04T17:33:18",
"witness": "dpay",
"transaction_merkle_root": "0000000000000000000000000000000000000000",
"extensions": [],
"witness_signature":
"205e1849df241ceb359d0f738f758be42ca55f3e345cd017ab3fff68c00f264c24373876fbafeacf2905914cea8d329df9f1cdd18d3b662d96579ebb10e75b77c5",
"transactions": [],
"block_id": "000003e8cc14da92f6beb0f9949a672cda19dd7b",
"signing_key": "DWB88FC9nDFczSTfVxrzHvVe8ZuvajLHKikfJYWiKkNvrUebBovzF",
"transaction_ids": []
}
}
from jefferson.cache.backends.max_ttl import SimplerMaxTTLMemoryCache
from jefferson.cache import CacheGroupItem
from jefferson.cache import SpeedTier
from jefferson.cache.cache_group import CacheGroup
from jefferson.cache.utils import jsonrpc_cache_key
from .conftest import make_request
from .conftest import build_mocked_cache
from jefferson.request.jsonrpc import from_http_request as jsonrpc_from_request
dummy_request = make_request()
jrpc_req_1 = jsonrpc_from_request(dummy_request, 0, {
"id": "1", "jsonrpc": "2.0",
"method": "get_block", "params": [1000]
})
jrpc_resp_1 = {
"id": 2,
"result": {
"previous": "000000011b5056ef5b610531031204f173aef7a8",
"timestamp": "2018-09-04T16:36:33",
"witness": "dpay",
"transaction_merkle_root": "0000000000000000000000000000000000000000",
"extensions": [],
"witness_signature": "1f39a1540cb5853377aa40c051ebde3fcc5a7b96d5b0881ed71ff10b8fcb6844711ed4920954ac80626486e49ba9ade4844813746590ab092bfc7ab1bca6a071b5",
"transactions": [],
"block_id": "00000002c4809dadc4e67ac65e57c9530ab16782",
"signing_key": "DWB88FC9nDFczSTfVxrzHvVe8ZuvajLHKikfJYWiKkNvrUebBovzF",
"transaction_ids": []}}
