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
Пример #4
0
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)
Пример #5
0
 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)
Пример #6
0
    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
Пример #10
0
    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()
Пример #13
0
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
Пример #15
0
def call(params):
    try:
        url = endpoint()
        response = HTTPClient(url).request("eth_call", params)
    except:
        return None

    return response
Пример #16
0
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")
Пример #17
0
def peer_count():
    try:
        url = endpoint()
        response = HTTPClient(url).request("net_peerCount", [])
    except:
        return None

    return response
Пример #18
0
def send_transaction(params):
    try:
        url = endpoint()
        response = HTTPClient(url).request("sushumna_sendTransaction", params)
    except:
        return None

    return response
Пример #19
0
def get_code(params):
    try:
        url = endpoint()
        response = HTTPClient(url).request("getCode", params)
    except:
        return None

    return response
Пример #20
0
def block_by_hash(params):
    try:
        url = endpoint()
        response = HTTPClient(url).request("cita_getBlockByHash", params)
    except:
        return None

    return response
Пример #21
0
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
Пример #22
0
def transaction_by_hash(tx_hash):
    try:
        url = endpoint()
        response = HTTPClient(url).request("sushumna_getTransaction", tx_hash)
    except:
        return None

    return response
Пример #23
0
 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)
Пример #24
0
 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)
Пример #25
0
def get_receipt_by(tx_hash):
    try:
        url = endpoint()
        response = HTTPClient(url).request("eth_getTransactionReceipt", tx_hash)
    except:
        return None

    return response
Пример #26
0
 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)
Пример #27
0
def block_number():
    try:
        url = endpoint()
        response = HTTPClient(url).request("blockNumber", [])
    except:
        return None

    return response
Пример #28
0
def get_transaction_count(params):
    try:
        url = endpoint()
        response = HTTPClient(url).request("eth_getTransactionCount", params)
    except:
        return None

    return response
Пример #29
0
def block_by_number(params):
    try:
        url = endpoint()
        response = HTTPClient(url).request("getBlockByNumber", params)
    except:
        return None

    return response
Пример #30
0
def get_logs(topics):
    try:
        url = endpoint()
        response = HTTPClient(url).request("eth_getLogs", topics=topics, fromBlock=0)
    except:
        return None

    return response