def test_http_basic_auth_user_in_request(live_server, john_doe, superuser,
common_pwd):
c = HTTPClient(live_server.url + '/all-rpc/')
c.session.auth = (john_doe.username, common_pwd)
assert 'username: johndoe' == c.display_authenticated_user()
c = HTTPClient(live_server.url + '/all-rpc/')
c.session.auth = (superuser.username, common_pwd)
assert 'username: admin' == c.display_authenticated_user()
def test_jsonrpc_anon_user_auth(live_server):
c = HTTPClient(live_server.url + '/all-rpc/')
assert raises(ReceivedErrorResponse, c.request, 'logged_user_required',
5).value.code == RPC_INTERNAL_ERROR
assert raises(ReceivedErrorResponse, c.request, 'logged_user_required_alt',
5).value.code == RPC_INTERNAL_ERROR
assert raises(ReceivedErrorResponse, c.request,
'logged_superuser_required',
5).value.code == RPC_INTERNAL_ERROR
assert raises(ReceivedErrorResponse, c.request,
'logged_superuser_required_alt',
5).value.code == RPC_INTERNAL_ERROR
assert raises(ReceivedErrorResponse, c.request,
'delete_user_perm_required',
5).value.code == RPC_INTERNAL_ERROR
assert raises(ReceivedErrorResponse, c.request, 'any_permission_required',
5).value.code == RPC_INTERNAL_ERROR
assert raises(ReceivedErrorResponse, c.request, 'all_permissions_required',
5).value.code == RPC_INTERNAL_ERROR
assert raises(ReceivedErrorResponse, c.request, 'in_group_A_required',
5).value.code == RPC_INTERNAL_ERROR
assert raises(ReceivedErrorResponse, c.request,
'in_groups_A_and_B_required',
5).value.code == RPC_INTERNAL_ERROR
e = raises(ReceivedErrorResponse, c.request,
'in_groups_A_and_B_required_alt', 5)
assert e.value.code == RPC_INTERNAL_ERROR
assert raises(ReceivedErrorResponse, c.request, 'in_group_A_or_B_required',
5).value.code == RPC_INTERNAL_ERROR
def test_jsonrpc_user_auth(live_server, john_doe, common_pwd):
c = HTTPClient(live_server.url + '/all-rpc/')
c.session.auth = (john_doe.username, common_pwd)
assert c.logged_user_required(5) == 5
assert c.logged_user_required_alt(5) == 5
assert raises(ReceivedErrorResponse, c.request,
'logged_superuser_required',
5).value.code == RPC_INTERNAL_ERROR
assert raises(ReceivedErrorResponse, c.request,
'logged_superuser_required_alt',
5).value.code == RPC_INTERNAL_ERROR
assert raises(ReceivedErrorResponse, c.request,
'delete_user_perm_required',
5).value.code == RPC_INTERNAL_ERROR
assert raises(ReceivedErrorResponse, c.request, 'any_permission_required',
5).value.code == RPC_INTERNAL_ERROR
assert raises(ReceivedErrorResponse, c.request, 'all_permissions_required',
5).value.code == RPC_INTERNAL_ERROR
assert raises(ReceivedErrorResponse, c.request, 'in_group_A_required',
5).value.code == RPC_INTERNAL_ERROR
assert raises(ReceivedErrorResponse, c.request,
'in_groups_A_and_B_required',
5).value.code == RPC_INTERNAL_ERROR
e = raises(ReceivedErrorResponse, c.request,
'in_groups_A_and_B_required_alt', 5)
assert e.value.code == RPC_INTERNAL_ERROR
assert raises(ReceivedErrorResponse, c.request, 'in_group_A_or_B_required',
5).value.code == RPC_INTERNAL_ERROR
def main(context, method, request_type, id, send):
"""
Create a JSON-RPC request.
"""
exit_status = 0
# Extract the jsonrpc arguments
positional = [a for a in context.args if '=' not in a]
named = {a.split('=')[0]: a.split('=')[1] for a in context.args if '=' in a}
# Create the request
if request_type == 'notify':
req = Notification(method, *positional, **named)
else:
req = Request(method, request_id=id, *positional, **named)
# Sending?
if send:
client = HTTPClient(send)
try:
response = client.send(req)
except JsonRpcClientError as e:
click.echo(str(e), err=True)
exit_status = 1
else:
click.echo(response)
# Otherwise, simply output the JSON-RPC request.
else:
click.echo(str(req))
sys.exit(exit_status)
def test_body(self):
client = HTTPClient('http://test/')
request = PreparedRequest(Request('go'))
client.prepare_request(request)
with self.assertRaises(requests.exceptions.RequestException):
client.send_message(request)
self.assertEqual(request, request.prepped.body)
def call(self,
method_name,
message=None,
timeout=None,
is_stub_reuse=True,
is_raise=False):
try:
version = self.__method_versions[method_name]
url = self.__version_urls[version]
method_name = self.__method_names[method_name]
if version == conf.ApiVersion.v1:
url += method_name
response = requests.get(
url, params={'channel': self.__channel_name})
else:
client = HTTPClient(url)
client.session.verify = conf.REST_SSL_VERIFY
response = client.request(
method_name,
message) if message else client.request(method_name)
util.logger.spam(
f"RestStubManager:call complete request_url({url}), "
f"method_name({method_name})")
return response
except Exception as e:
logging.warning(
f"REST call fail method_name({method_name}), caused by : {e}")
raise e
def test_jsonrpc_bool_2(live_server):
c = HTTPClient(live_server.url + '/all-rpc/')
result = c.get_false()
assert type(result) == bool
assert result is False
def test_jsonrpc_int_negative(live_server):
c = HTTPClient(live_server.url + '/all-rpc/')
result = c.get_negative_int()
assert type(result) == int
assert result == -42
def test_jsonrpc_float(live_server):
c = HTTPClient(live_server.url + '/all-rpc/')
result = c.get_float()
assert type(result) == float
assert result == 3.14
def create_token(self, *args, **kwargs):
"""
create kol token
Accepts:
- token_name [string] token name
- token_symbol [string] toke symbol
- total_supply [int] token total supply
- decimals [int] token precision from 1 to 18
- blockchain [string] blockchain to create token on ( QTUMTEST, ETHTEST )
- is_burnable [Bool] can burn tokens
- is_mintable [Bool] can create new tokens
Returns dictionary with following fields:
- txid [string]
- address [string]
"""
client = HTTPClient(self.withdraw_server_address +
self.withdraw_endpoint)
if check_sig:
return client.request('create_token',
self.signature_validator.sign(kwargs))
else:
return client.request('create_token', kwargs)
def test_jsonrpc_protocol_specific_methods(live_server):
c = HTTPClient(live_server.url + '/json-only/')
methods_list = c.request('system.listMethods')
assert 'method_x' in methods_list
assert 'method_y' not in methods_list
def test_custom_predicate_allowed(live_server):
c = HTTPClient(live_server.url + '/all-rpc/')
assert 'python-requests' in c.get_user_agent()
c = xmlrpc_client.ServerProxy(live_server.url + '/all-rpc/')
assert 'xmlrpc' in c.get_user_agent()
def test_method_level_str_std(live_server):
jclient = HTTPClient(live_server.url + '/all-rpc/')
assert jclient.force_unicode_input("abcde") == "<type 'unicode'>"
xclient = xmlrpc_client.ServerProxy(live_server.url + '/all-rpc/')
assert xclient.force_unicode_input("abcde") == "<type 'unicode'>"
def test_jsonrpc_get_signature(live_server):
c = HTTPClient(live_server.url + '/all-rpc/')
signature = c.request('system.methodSignature', "add")
# This one doesn not have any docstring defined
assert type(signature) == list
assert len(signature) == 0
def call(params):
try:
url = endpoint()
response = HTTPClient(url).request("eth_call", params)
except:
return None
return response
def update_ETH_cid():
client = HTTPClient("http://localhost:8007/api/bridge")
cid = client.request(method_name="get_next_cid")["next_cid"]
content = list(MongoClient().ETH.content.find())[-1]
txid = content["txid"]
MongoClient().ETH.content.find_one_and_update(
{"txid":txid},{"$set":{"cid":int(cid)-1}})
print("Done")
def peer_count():
try:
url = endpoint()
response = HTTPClient(url).request("net_peerCount", [])
except:
return None
return response
def send_transaction(params):
try:
url = endpoint()
response = HTTPClient(url).request("sushumna_sendTransaction", params)
except:
return None
return response
def get_code(params):
try:
url = endpoint()
response = HTTPClient(url).request("getCode", params)
except:
return None
return response
def block_by_hash(params):
try:
url = endpoint()
response = HTTPClient(url).request("cita_getBlockByHash", params)
except:
return None
return response
def test_jsonrpc_exception_with_data(live_server):
client = HTTPClient(live_server.url + '/all-rpc/')
with pytest.raises(ReceivedErrorResponse) as excinfo:
client.raise_custom_exception_with_data()
assert ['a', 'b', 'c'] == excinfo.value.data
def transaction_by_hash(tx_hash):
try:
url = endpoint()
response = HTTPClient(url).request("sushumna_getTransaction", tx_hash)
except:
return None
return response
def test_init_default_headers(self):
client = HTTPClient('http://test/')
# Default headers
self.assertEqual('application/json',
client.session.headers['Content-Type'])
self.assertEqual('application/json', client.session.headers['Accept'])
# Ensure the Requests default_headers are also there
self.assertIn('Connection', client.session.headers)
def test_ssl_verification(self):
client = HTTPClient('https://test/')
client.session.cert = '/path/to/cert'
client.session.verify = 'ca-cert'
request = PreparedRequest(Request('go'))
client.prepare_request(request)
with self.assertRaises(requests.exceptions.RequestException):
client.send_message(request)
def get_receipt_by(tx_hash):
try:
url = endpoint()
response = HTTPClient(url).request("eth_getTransactionReceipt", tx_hash)
except:
return None
return response
def test_ssl_verification(self):
client = HTTPClient('https://test/')
client.session.cert = '/path/to/cert'
client.session.verify = 'ca-cert'
request = PreparedRequest(Request('go'))
client.prepare_request(request)
with self.assertRaises(OSError): # Invalid certificate
client.send_message(request)
def block_number():
try:
url = endpoint()
response = HTTPClient(url).request("blockNumber", [])
except:
return None
return response
def get_transaction_count(params):
try:
url = endpoint()
response = HTTPClient(url).request("eth_getTransactionCount", params)
except:
return None
return response
def block_by_number(params):
try:
url = endpoint()
response = HTTPClient(url).request("getBlockByNumber", params)
except:
return None
return response
def get_logs(topics):
try:
url = endpoint()
response = HTTPClient(url).request("eth_getLogs", topics=topics, fromBlock=0)
except:
return None
return response
