def mock_api_query_response(endpoint, method='', options=None): # pylint: disable=unused-argument # noqa: E501
return MockResponse(
HTTPStatus.FORBIDDEN,
f'{{"code": "{API_ERR_AUTH_NONCE_CODE}", "reason": "whatever"}}',
)
def mock_exchanges_rateapi_fail(url, timeout): # pylint: disable=unused-argument
nonlocal count
count += 1
if 'exchangeratesapi' in url:
return MockResponse(501, '{"msg": "some error")')
return original_get(url)
def mock_api_remote_fail(url, timeout): # pylint: disable=unused-argument
return MockResponse(500, '{"msg": "shit hit the fan"')
def mock_requests_requests(method, url, *args, **kwargs):
if 'transfers' not in url:
return original_requests_request(method, url, *args, **kwargs)
return MockResponse(200, TRANSFERS_RESPONSE)
def mock_order_history(url, method, json): # pylint: disable=unused-argument
response = MockResponse(200, BITTREX_ORDER_HISTORY_RESPONSE)
return response
def mock_requests_get(url, *args, **kwargs):
if 'etherscan.io/api?module=account&action=balance&address' in url:
addr = url[67:109]
value = eth_map[addr].get('ETH', '0')
response = f'{{"status":"1","message":"OK","result":{value}}}'
elif 'etherscan.io/api?module=account&action=balancemulti' in url:
queried_accounts = []
length = 72
# process url and get the accounts
while True:
if len(url) < length:
break
potential_address = url[length:length + 42]
if 'apikey=' in potential_address:
break
queried_accounts.append(potential_address)
length += 43
accounts = []
for addr in queried_accounts:
value = eth_map[addr].get('ETH', '0')
accounts.append({'account': addr, 'balance': eth_map[addr]['ETH']})
response = f'{{"status":"1","message":"OK","result":{json.dumps(accounts)}}}'
elif 'api.etherscan.io/api?module=account&action=tokenbalance' in url:
token_address = url[80:122]
msg = 'token address missing from test mapping'
assert token_address in CONTRACT_ADDRESS_TO_TOKEN, msg
response = '{"status":"1","message":"OK","result":"0"}'
token = CONTRACT_ADDRESS_TO_TOKEN[token_address]
account = url[131:173]
value = eth_map[account].get(token.identifier, 0)
response = f'{{"status":"1","message":"OK","result":"{value}"}}'
elif 'api.etherscan.io/api?module=account&action=txlistinternal&' in url:
if 'transactions' in original_queries:
return original_requests_get(url, *args, **kwargs)
# By default when mocking, don't query for transactions
response = '{"status":"1","message":"OK","result":[]}'
elif 'api.etherscan.io/api?module=account&action=txlist&' in url:
if 'transactions' in original_queries:
return original_requests_get(url, *args, **kwargs)
# By default when mocking, don't query for transactions
response = '{"status":"1","message":"OK","result":[]}'
elif 'api.etherscan.io/api?module=logs&action=getLogs&' in url:
if 'logs' in original_queries:
return original_requests_get(url, *args, **kwargs)
# By default when mocking, don't query logs
response = '{"status":"1","message":"OK","result":[]}'
elif 'api.etherscan.io/api?module=block&action=getblocknobytime&' in url:
if 'blocknobytime' in original_queries:
return original_requests_get(url, *args, **kwargs)
# By default when mocking don't query blocknobytime
response = '{"status":"1","message":"OK","result":"1"}'
elif f'api.etherscan.io/api?module=proxy&action=eth_call&to={ZERION_ADAPTER_ADDRESS}' in url: # noqa: E501
if 'zerion' in original_queries:
return original_requests_get(url, *args, **kwargs)
web3 = Web3()
contract = web3.eth.contract(address=ZERION_ADAPTER_ADDRESS, abi=ZERION_ABI)
if 'data=0xc84aae17' in url: # getBalances
data = url.split('data=')[1]
if '&apikey' in data:
data = data.split('&apikey')[0]
fn_abi = contract._find_matching_fn_abi(
fn_identifier='getBalances',
args=['address'],
)
input_types = get_abi_input_types(fn_abi)
output_types = get_abi_output_types(fn_abi)
decoded_input = web3.codec.decode_abi(input_types, bytes.fromhex(data[10:]))
# TODO: This here always returns empty response. If/when we want to
# mock it for etherscan, this is where we do it
args = []
result = '0x' + web3.codec.encode_abi(output_types, [args]).hex()
response = f'{{"jsonrpc":"2.0","id":1,"result":"{result}"}}'
elif 'data=0x85c6a7930' in url: # getProtocolBalances
data = url.split('data=')[1]
if '&apikey' in data:
data = data.split('&apikey')[0]
fn_abi = contract._find_matching_fn_abi(
fn_identifier='getProtocolBalances',
args=['address', ['some', 'protocol', 'names']],
)
input_types = get_abi_input_types(fn_abi)
output_types = get_abi_output_types(fn_abi)
decoded_input = web3.codec.decode_abi(input_types, bytes.fromhex(data[10:]))
# TODO: This here always returns empty response. If/when we want to
# mock it for etherscan, this is where we do it
args = []
result = '0x' + web3.codec.encode_abi(output_types, [args]).hex()
response = f'{{"jsonrpc":"2.0","id":1,"result":"{result}"}}'
elif 'data=0x3b692f52' in url: # getProtocolNames
data = url.split('data=')[1]
if '&apikey' in data:
data = data.split('&apikey')[0]
fn_abi = contract._find_matching_fn_abi(
fn_identifier='getProtocolNames',
)
input_types = get_abi_input_types(fn_abi)
output_types = get_abi_output_types(fn_abi)
decoded_input = web3.codec.decode_abi(input_types, bytes.fromhex(data[10:]))
# TODO: This here always returns empty response. If/when we want to
# mock it for etherscan, this is where we do it
args = []
result = '0x' + web3.codec.encode_abi(output_types, [args]).hex()
response = f'{{"jsonrpc":"2.0","id":1,"result":"{result}"}}'
else:
raise AssertionError(f'Unexpected etherscan call during tests: {url}')
elif 'api.etherscan.io/api?module=proxy&action=eth_call&to=0xB6456b57f03352bE48Bf101B46c1752a0813491a' in url: # noqa: E501 # ADEX Staking contract
if 'adex_staking' in original_queries:
return original_requests_get(url, *args, **kwargs)
if 'data=0x447b15f4' in url: # a mocked share value
response = '{"jsonrpc":"2.0","id":1,"result":"0x0000000000000000000000000000000000000000000000000fc4a48782d85b51"}' # noqa: E501
else:
raise AssertionError(f'Unknown call to Adex Staking pool during tests: {url}')
elif f'api.etherscan.io/api?module=proxy&action=eth_call&to={ETH_MULTICALL.address}' in url: # noqa: E501
web3 = Web3()
contract = web3.eth.contract(address=ETH_MULTICALL.address, abi=ETH_MULTICALL.abi)
if 'b6456b57f03352be48bf101b46c1752a0813491a' in url:
multicall_purpose = 'adex_staking'
elif '5f3b5dfeb7b28cdbd7faba78963ee202a494e2a2' in url:
multicall_purpose = 'vecrv'
else:
raise AssertionError('Unknown multicall in mocked tests')
if 'data=0x252dba42' in url: # aggregate
if multicall_purpose == 'adex_staking':
if 'adex_staking' in original_queries:
return original_requests_get(url, *args, **kwargs)
if 'mocked_adex_staking_balance' in extra_flags:
# mock adex staking balance for a single account
response = '{"jsonrpc": "2.0", "id": 1, "result": "0x0000000000000000000000000000000000000000000000000000000000bb45aa000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000152982285d2e4d5aeaa9"}' # noqa: E501
return MockResponse(200, response)
data = url.split('data=')[1]
if '&apikey' in data:
data = data.split('&apikey')[0]
fn_abi = contract.functions.abi[1]
assert fn_abi['name'] == 'aggregate', 'Abi position of multicall aggregate changed'
input_types = get_abi_input_types(fn_abi)
output_types = get_abi_output_types(fn_abi)
decoded_input = web3.codec.decode_abi(input_types, bytes.fromhex(data[10:]))
# For now the only mocked multicall is 32 bytes for multicall balance
# of both veCRV and adex staking pool.
# When there is more we have to figure out a way to differentiate
# between them in mocking. Just return empty response here
# all pylint ignores below due to https://github.com/PyCQA/pylint/issues/4114
args = [1, [b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00' for x in decoded_input[0]]] # pylint: disable=unsubscriptable-object # noqa: E501
result = '0x' + web3.codec.encode_abi(output_types, args).hex()
response = f'{{"jsonrpc":"2.0","id":1,"result":"{result}"}}'
else:
raise AssertionError('Unexpected etherscan multicall during tests: {url}')
elif f'api.etherscan.io/api?module=proxy&action=eth_call&to={ETH_SCAN.address}' in url:
if 'ethscan' in original_queries:
return original_requests_get(url, *args, **kwargs)
web3 = Web3()
contract = web3.eth.contract(address=ETH_SCAN.address, abi=ETH_SCAN.abi)
if 'data=0xdbdbb51b' in url: # Eth balance query
data = url.split('data=')[1]
if '&apikey' in data:
data = data.split('&apikey')[0]
fn_abi = contract._find_matching_fn_abi(
fn_identifier='etherBalances',
args=[list(eth_map.keys())],
)
input_types = get_abi_input_types(fn_abi)
output_types = get_abi_output_types(fn_abi)
decoded_input = web3.codec.decode_abi(input_types, bytes.fromhex(data[10:]))
args = []
for account_address in decoded_input[0]: # pylint: disable=unsubscriptable-object # noqa: E501
account_address = deserialize_ethereum_address(account_address)
args.append(int(eth_map[account_address]['ETH']))
result = '0x' + web3.codec.encode_abi(output_types, [args]).hex()
response = f'{{"jsonrpc":"2.0","id":1,"result":"{result}"}}'
elif 'data=0x06187b4f' in url: # Multi token multiaddress balance query
data = url.split('data=')[1]
if '&apikey' in data:
data = data.split('&apikey')[0]
# not really the given args, but we just want the fn abi
args = [list(eth_map.keys()), list(eth_map.keys())]
fn_abi = contract._find_matching_fn_abi(
fn_identifier='tokensBalances',
args=args,
)
input_types = get_abi_input_types(fn_abi)
output_types = get_abi_output_types(fn_abi)
decoded_input = web3.codec.decode_abi(input_types, bytes.fromhex(data[10:]))
args = []
for account_address in decoded_input[0]: # pylint: disable=unsubscriptable-object # noqa: E501
account_address = deserialize_ethereum_address(account_address)
x = []
for token_address in decoded_input[1]: # pylint: disable=unsubscriptable-object # noqa: E501
token_address = deserialize_ethereum_address(token_address)
value_to_add = 0
for given_asset, value in eth_map[account_address].items():
given_asset = _get_token(given_asset)
if given_asset is None:
# not a token
continue
if token_address != given_asset.ethereum_address:
continue
value_to_add = int(value)
break
x.append(value_to_add)
args.append(x)
result = '0x' + web3.codec.encode_abi(output_types, [args]).hex()
response = f'{{"jsonrpc":"2.0","id":1,"result":"{result}"}}'
elif 'data=0xe5da1b68' in url: # Multi token balance query
data = url.split('data=')[1]
if '&apikey' in data:
data = data.split('&apikey')[0]
# not really the given args, but we just want the fn abi
args = ['str', list(eth_map.keys())]
fn_abi = contract._find_matching_fn_abi(
fn_identifier='tokensBalance',
args=args,
)
input_types = get_abi_input_types(fn_abi)
output_types = get_abi_output_types(fn_abi)
decoded_input = web3.codec.decode_abi(input_types, bytes.fromhex(data[10:]))
args = []
account_address = deserialize_ethereum_address(decoded_input[0]) # pylint: disable=unsubscriptable-object # noqa: E501
x = []
for token_address in decoded_input[1]: # pylint: disable=unsubscriptable-object # noqa: E501
token_address = deserialize_ethereum_address(token_address)
value_to_add = 0
for given_asset, value in eth_map[account_address].items():
given_asset = _get_token(given_asset)
if given_asset is None:
# not a token
continue
if token_address != given_asset.ethereum_address:
continue
value_to_add = int(value)
break
args.append(value_to_add)
result = '0x' + web3.codec.encode_abi(output_types, [args]).hex()
response = f'{{"jsonrpc":"2.0","id":1,"result":"{result}"}}'
else:
raise AssertionError(f'Unexpected etherscan call during tests: {url}')
else:
return original_requests_get(url, *args, **kwargs)
return MockResponse(200, response)
def mock_poloniex_api_queries(url, req): # pylint: disable=unused-argument
payload = ''
if 'returnTradeHistory' == req['command']:
payload = """{
"BTC_ETH": [{
"globalTradeID": 394131412,
"tradeID": "5455033",
"date": "2018-10-16 18:05:17",
"rate": "0.06935244",
"amount": "1.40308443",
"total": "0.09730732",
"fee": "0.00100000",
"orderNumber": "104768235081",
"type": "sell",
"category": "exchange"
}, {
"globalTradeID": 394131413,
"tradeID": "5455034",
"date": "2018-10-16 18:07:17",
"rate": "0.06935244",
"amount": "1.40308443",
"total": "0.09730732",
"fee": "0.00100000",
"orderNumber": "104768235081",
"type": "buy",
"category": "exchange"
}],
"ETH_XMR": [{
"globalTradeID": 394131415,
"tradeID": "5455036",
"date": "2018-10-16 18:07:18",
"rate": "0.06935244",
"amount": "1.40308443",
"total": "0.09730732",
"fee": "0.00100000",
"orderNumber": "104768235081",
"type": "buy",
"category": "exchange"
}],
"ETH_NOEXISTINGASSET": [{
"globalTradeID": 394131416,
"tradeID": "5455036",
"date": "2018-10-16 18:07:17",
"rate": "0.06935244",
"amount": "1.40308443",
"total": "0.09730732",
"fee": "0.00100000",
"orderNumber": "104768235081",
"type": "buy",
"category": "exchange"
}],
"ETH_BALLS": [{
"globalTradeID": 394131417,
"tradeID": "5455036",
"date": "2018-10-16 18:07:17",
"rate": "0.06935244",
"amount": "1.40308443",
"total": "0.09730732",
"fee": "0.00100000",
"orderNumber": "104768235081",
"type": "buy",
"category": "exchange"
}]
}"""
elif 'returnLendingHistory' == req['command']:
payload = """[{
"id": 246300115,
"currency": "BTC",
"rate": "0.00013890",
"amount": "0.33714830",
"duration": "0.00090000",
"interest": "0.00000005",
"fee": "0.00000000",
"earned": "0.00000005",
"open": "2017-01-01 23:41:37",
"close": "2017-01-01 23:42:51"
}, {
"id": 246294775,
"currency": "ETH",
"rate": "0.00013890",
"amount": "0.03764586",
"duration": "0.00150000",
"interest": "0.00000001",
"fee": "0.00000000",
"earned": "0.00000001",
"open": "2017-01-01 23:36:32",
"close": "2017-01-01 23:38:45"
}, {
"id": 246294776,
"currency": "NOTEXISTINGASSET",
"rate": "0.00013890",
"amount": "0.03764586",
"duration": "0.00150000",
"interest": "0.00000001",
"fee": "0.00000000",
"earned": "0.00000001",
"open": "2017-01-01 23:36:32",
"close": "2017-01-01 23:38:45"
}, {
"id": 246294777,
"currency": "BDC",
"rate": "0.00013890",
"amount": "0.03764586",
"duration": "0.00150000",
"interest": "0.00000001",
"fee": "0.00000000",
"earned": "0.00000001",
"open": "2017-01-01 23:36:32",
"close": "2017-01-01 23:38:45"
}]"""
elif 'returnDepositsWithdrawals' == req['command']:
payload = POLONIEX_MOCK_DEPOSIT_WITHDRAWALS_RESPONSE
else:
raise RuntimeError(
f'Poloniex test mock got unexpected/unmocked command {req["command"]}',
)
return MockResponse(200, payload)
def mock_coinbase_accounts(url): # pylint: disable=unused-argument
response = MockResponse(
200,
"""
{
"pagination": {
"ending_before": null,
"starting_after": null,
"limit": 25,
"order": "desc",
"previous_uri": null,
"next_uri": null
},
"data": [
{
"id": "58542935-67b5-56e1-a3f9-42686e07fa40",
"name": "My Vault",
"primary": false,
"type": "vault",
"currency": "BTC",
"balance": {
"amount": "4.00000000",
"currency": "BTC"
},
"created_at": "2015-01-31T20:49:02Z",
"updated_at": "2015-01-31T20:49:02Z",
"resource": "account",
"resource_path": "/v2/accounts/58542935-67b5-56e1-a3f9-42686e07fa40",
"ready": true
},
{
"id": "2bbf394c-193b-5b2a-9155-3b4732659ede",
"name": "My Wallet",
"primary": true,
"type": "wallet",
"currency": "ETH",
"balance": {
"amount": "39.59000000",
"currency": "ETH"
},
"created_at": "2015-01-31T20:49:02Z",
"updated_at": "2015-01-31T20:49:02Z",
"resource": "account",
"resource_path": "/v2/accounts/2bbf394c-193b-5b2a-9155-3b4732659ede"
},
{
"id": "68542935-67b5-56e1-a3f9-42686e07fa40",
"name": "Another Wallet",
"primary": false,
"type": "vault",
"currency": "BTC",
"balance": {
"amount": "1.230000000",
"currency": "BTC"
},
"created_at": "2015-01-31T20:49:02Z",
"updated_at": "2015-01-31T20:49:02Z",
"resource": "account",
"resource_path": "/v2/accounts/68542935-67b5-56e1-a3f9-42686e07fa40",
"ready": true
}
]
}
""",
)
return response
def mock_github_return_current(url): # pylint: disable=unused-argument
contents = '{"tag_name": "v1.4.0", "html_url": "https://foo"}'
return MockResponse(200, contents)
def mock_etherscan_get(url, *args, **kwargs): # pylint: disable=unused-argument
return MockResponse(200, "{}")
def mock_coinbase_accounts(url): # pylint: disable=unused-argument
return MockResponse(200, response_str)
def mock_xratescom_fail(url, timeout): # pylint: disable=unused-argument
nonlocal count
count += 1
if 'www.x-rates.com' in url:
return MockResponse(501, '{"msg": "some error")')
return original_get(url)
def mock_api_return(url, **kwargs): # pylint: disable=unused-argument
if 'pageNumber=0' in url:
return MockResponse(200, ICONOMI_TRADES_RESPONSE)
return MockResponse(200, ICONOMI_TRADES_EMPTY_RESPONSE)
def mock_unknown_asset_return(url, **kwargs): # pylint: disable=unused-argument
return MockResponse(200, ICONOMI_BALANCES_RESPONSE)
def mock_api_return(url, req): # pylint: disable=unused-argument
return MockResponse(200, given_movements)
def mock_non_200_github_return(url): # pylint: disable=unused-argument
contents = '{"tag_name": "v99.99.99", "html_url": "https://foo"}'
return MockResponse(501, contents)
def mock_requests_get(url, *args, **kwargs):
if 'etherscan.io/api?module=proxy&action=eth_blockNumber' in url:
response = f'{{"status":"1","message":"OK","result":"{TEST_LATEST_BLOCKNUMBER_HEX}"}}'
elif 'etherscan.io/api?module=proxy&action=eth_call' in url:
to_address = url.split(
'https://api.etherscan.io/api?module=proxy&action=eth_call&to=',
)[1][:42]
input_data = url.split('data=')[1].split('&apikey')[0]
if to_address == MAKERDAO_PROXY_REGISTRY.address:
if not input_data.startswith('0xc4552791'):
raise AssertionError(
'Call to unexpected method of DSR ProxyRegistry during tests',
)
# It's a call to proxy registry. Return the mapping
if account1[2:].lower() in input_data:
proxy_account = address_to_32byteshexstr(proxy1)
elif account2[2:].lower() in input_data:
proxy_account = address_to_32byteshexstr(proxy2)
else:
proxy_account = '0x' + '0' * 64
response = f'{{"status":"1","message":"OK","result":"{proxy_account}"}}'
elif to_address == MAKERDAO_POT.address:
if input_data.startswith('0x0bebac86'): # pie
if proxy1[2:].lower() in input_data:
result = int_to_32byteshexstr(
params.account1_current_normalized_balance)
elif proxy2[2:].lower() in input_data:
result = int_to_32byteshexstr(
params.account2_current_normalized_balance)
else:
# result = int_to_32byteshexstr(0)
raise AssertionError(
'Pie call for unexpected account during tests')
elif input_data.startswith('0xc92aecc4'): # chi
result = int_to_32byteshexstr(params.current_chi)
elif input_data.startswith('0x487bf082'): # dsr
result = int_to_32byteshexstr(params.current_dsr)
else:
raise AssertionError(
'Call to unexpected method of MakerDAO pot during tests',
)
response = f'{{"status":"1","message":"OK","result":"{result}"}}'
else:
raise AssertionError(
f'Etherscan call to unknown contract {to_address} during tests',
)
elif 'etherscan.io/api?module=logs&action=getLogs' in url:
contract_address = url.split('&address=')[1].split('&topic0')[0]
topic0 = url.split('&topic0=')[1].split('&topic0_1')[0]
topic1 = url.split('&topic1=')[1].split('&topic1_2')[0]
topic2 = None
if '&topic2=' in url:
topic2 = url.split('&topic2=')[1].split('&')[0]
from_block = int(url.split('&fromBlock=')[1].split('&')[0])
to_block = int(url.split('&toBlock=')[1].split('&')[0])
if contract_address == MAKERDAO_POT.address:
if topic0.startswith('0x049878f3'): # join
events = []
if proxy1[2:].lower() in topic1:
if from_block <= params.account1_join1_blocknumber <= to_block:
events.append(account1_join1_event)
if from_block <= params.account1_join2_blocknumber <= to_block:
events.append(account1_join2_event)
elif proxy2[2:].lower() in topic1:
if from_block <= params.account2_join1_blocknumber <= to_block:
events.append(account2_join1_event)
else:
raise AssertionError(
f'Etherscan log query to makerdao POT contract for '
f'join for unknown account {topic1}', )
response = f'{{"status":"1","message":"OK","result":[{",".join(events)}]}}'
elif topic0.startswith('0x7f8661a1'): # exit
events = []
if proxy1[2:].lower() in topic1:
if from_block <= params.account1_exit1_blocknumber <= to_block:
events.append(account1_exit1_event)
response = f'{{"status":"1","message":"OK","result":[{",".join(events)}]}}'
else:
raise AssertionError(
'Etherscan unknown log query to makerdao POT contract')
elif contract_address == MAKERDAO_VAT.address:
if topic0.startswith('0xbb35783b'): # move
events = []
if proxy1[2:].lower() in topic1: # deposit from acc1
if from_block <= params.account1_join1_blocknumber <= to_block:
events.append(account1_join1_move_event)
if from_block <= params.account1_join2_blocknumber <= to_block:
events.append(account1_join2_move_event)
elif proxy2[2:].lower() in topic1: # deposit from acc2
if from_block <= params.account2_join1_blocknumber <= to_block:
events.append(account2_join1_move_event)
elif proxy1[2:].lower() in topic2: # withdrawal from acc1
if from_block <= params.account1_exit1_blocknumber <= to_block:
events.append(account1_exit1_move_event)
response = f'{{"status":"1","message":"OK","result":[{",".join(events)}]}}'
else:
raise AssertionError(
'Etherscan unknown log query to makerdao VAT contract')
elif contract_address == MAKERDAO_DAI_JOIN.address:
events = []
if topic0.startswith('0x3b4da69f'): # join
if proxy1[2:].lower() in topic1: # deposit from acc1
if from_block <= params.account1_join1_blocknumber <= to_block:
events.append(account1_join1_move_event)
if from_block <= params.account1_join2_blocknumber <= to_block:
events.append(account1_join2_move_event)
elif proxy2[2:].lower() in topic1: # deposit from acc2
if from_block <= params.account2_join1_blocknumber <= to_block:
events.append(account2_join1_move_event)
elif topic0.startswith('0xef693bed'): # exit
if from_block <= params.account1_exit1_blocknumber <= to_block:
events.append(account1_exit1_move_event)
else:
raise AssertionError(
'Etherscan unknown call to makerdao DAIJOIN contract')
response = f'{{"status":"1","message":"OK","result":[{",".join(events)}]}}'
else:
raise AssertionError(
f'Etherscan getLogs call to unknown contract {contract_address} during tests',
)
else:
return original_requests_get(url, *args, **kwargs)
return MockResponse(200, response)
def mock_missing_fields_github_return(url): # pylint: disable=unused-argument
contents = '{"html_url": "https://foo"}'
return MockResponse(200, contents)
def do_mock_get_saved_data(url, data, timeout): # pylint: disable=unused-argument
assert len(data) == 1
assert 'nonce' in data
assert timeout == ROTKEHLCHEN_SERVER_TIMEOUT
payload = f'{{"data": "{saved_data.decode()}"}}'
return MockResponse(200, payload)
def mock_invalid_json_github_return(url): # pylint: disable=unused-argument
contents = '{html_url: "https://foo"}'
return MockResponse(200, contents)
def mock_bittrex_api_queries(url):
if 'getorderhistory' in url:
payload = """
{
"success": true,
"message": "''",
"result": [{
"OrderUuid": "fd97d393-e9b9-4dd1-9dbf-f288fc72a185",
"Exchange": "BTC-LTC",
"TimeStamp": "2017-05-01T15:00:00.00",
"OrderType": "LIMIT_BUY",
"Limit": 1e-8,
"Quantity": 667.03644955,
"QuantityRemaining": 0,
"Commission": 0.00004921,
"Price": 0.01968424,
"PricePerUnit": 0.0000295,
"IsConditional": false,
"ImmediateOrCancel": false
}, {
"OrderUuid": "ad97d393-e9b9-4dd1-9dbf-f288fc72a185",
"Exchange": "ETH-LTC",
"TimeStamp": "2017-05-02T15:00:00.00",
"OrderType": "LIMIT_SELL",
"Limit": 1e-8,
"Quantity": 667.03644955,
"QuantityRemaining": 0,
"Commission": 0.00004921,
"Price": 0.01968424,
"PricePerUnit": 0.0000295,
"IsConditional": false,
"ImmediateOrCancel": false
}, {
"OrderUuid": "ed97d393-e9b9-4dd1-9dbf-f288fc72a185",
"Exchange": "PTON-ETH",
"TimeStamp": "2017-05-02T15:00:00.00",
"OrderType": "LIMIT_SELL",
"Limit": 1e-8,
"Quantity": 667.03644955,
"QuantityRemaining": 0,
"Commission": 0.00004921,
"Price": 0.01968424,
"PricePerUnit": 0.0000295,
"IsConditional": false,
"ImmediateOrCancel": false
}, {
"OrderUuid": "1d97d393-e9b9-4dd1-9dbf-f288fc72a185",
"Exchange": "ETH-IDONTEXIST",
"TimeStamp": "2017-05-02T15:00:00.00",
"OrderType": "LIMIT_SELL",
"Limit": 1e-8,
"Quantity": 667.03644955,
"QuantityRemaining": 0,
"Commission": 0.00004921,
"Price": 0.01968424,
"PricePerUnit": 0.0000295,
"IsConditional": false,
"ImmediateOrCancel": false
}, {
"OrderUuid": "2d97d393-e9b9-4dd1-9dbf-f288fc72a185",
"Exchange": "%$#%$#%#$%",
"TimeStamp": "2017-05-02T15:00:00.00",
"OrderType": "LIMIT_BUY",
"Limit": 1e-8,
"Quantity": 667.03644955,
"QuantityRemaining": 0,
"Commission": 0.00004921,
"Price": 0.01968424,
"PricePerUnit": 0.0000295,
"IsConditional": false,
"ImmediateOrCancel": false
}]
}
"""
else:
raise RuntimeError(
f'Bittrex test mock got unexpected/unmocked url {url}')
return MockResponse(200, payload)
def mock_bitmex_api_queries(url, data): # pylint: disable=unused-argument
if remote_errors:
payload = invalid_payload
elif 'user/walletHistory' in url:
payload = """[{
"transactID": "id1",
"account": 0,
"currency": "XBt",
"transactType": "Deposit",
"amount": 15000000,
"fee": 0,
"transactStatus": "foo",
"address": "foo",
"tx": "foo",
"text": "foo",
"transactTime": "2017-04-03T15:00:00.929Z",
"timestamp": "2017-04-03T15:00:00.929Z"
},{
"transactID": "id2",
"account": 0,
"currency": "XBt",
"transactType": "RealisedPNL",
"amount": 5000000,
"fee": 0.01,
"transactStatus": "foo",
"address": "foo",
"tx": "foo",
"text": "foo",
"transactTime": "2017-05-02T15:00:00.929Z",
"timestamp": "2017-05-02T15:00:00.929Z"
},{
"transactID": "id3",
"account": 0,
"currency": "XBt",
"transactType": "Withdrawal",
"amount": 1000000,
"fee": 0.001,
"transactStatus": "foo",
"address": "foo",
"tx": "foo",
"text": "foo",
"transactTime": "2017-05-23T15:00:00.00.929Z",
"timestamp": "2017-05-23T15:00:00.929Z"
},{
"transactID": "id4",
"account": 0,
"currency": "XBt",
"transactType": "Withdrawal",
"amount": 0.5,
"fee": 0.001,
"transactStatus": "foo",
"address": "foo",
"tx": "foo",
"text": "foo",
"transactTime": "2019-08-23T15:00:00.00.929Z",
"timestamp": "2019-08-23T15:00:00.929Z"
},{
"transactID": "id5",
"account": 0,
"currency": "XBt",
"transactType": "RealisedPNL",
"amount": 0.5,
"fee": 0.001,
"transactStatus": "foo",
"address": "foo",
"tx": "foo",
"text": "foo",
"transactTime": "2019-08-23T15:00:00.929Z",
"timestamp": "2019-08-23T15:00:00.929Z"
}]"""
else:
raise RuntimeError(f'Bitmex test mock got unexpected/unmocked url {url}')
return MockResponse(200, payload)
"currencySymbol": "BTC",
"confirmations": 2,
"completedAt": "2014-07-09T04:24:47.217Z",
"txId": "e26d3b33fcfc2cb0c74d0938034956ea590339170bf4102f080eab4b85da9bde",
"cryptoAddress": "1DeaaFBdbB5nrHj87x3NHS4onvw1GPNyAu",
"source": "foo"
}]"""
check_permutations_of_input_invalid_data(
deposits=input_deposits,
withdrawals=empty_response,
)
@pytest.mark.parametrize('response, exception', [
(
MockResponse(HTTPStatus.OK, '{"result": "a result"}'),
None,
),
(
MockResponse(HTTPStatus.UNAUTHORIZED, 'this is not a dict'),
RemoteError,
),
(
MockResponse(HTTPStatus.UNAUTHORIZED,
'{"code": "NOT_THE_EXPECTED_CODE"}'),
None,
),
(
MockResponse(HTTPStatus.UNAUTHORIZED,
'{"not_code": "INVALID_TIMESTAMP"}'),
None,
def mock_api_return(url, req): # pylint: disable=unused-argument
return MockResponse(200, POLONIEX_TRADES_RESPONSE)
def mock_response(url, method, json): # pylint: disable=unused-argument
response = MockResponse(HTTPStatus.UNAUTHORIZED,
'{"code": "INVALID_TIMESTAMP"}')
return response
def mock_unknown_asset_return(url, req): # pylint: disable=unused-argument
return MockResponse(200, POLONIEX_BALANCES_RESPONSE)
def mock_currency_converter_api(url, timeout): # pylint: disable=unused-argument
return MockResponse(200, '{"results": {"USD_EUR": {"val": 1.1543, "id": "USD_EUR"}}}')
def mock_api_return(url, req): # pylint: disable=unused-argument
response = MockResponse(
200,
POLONIEX_MOCK_DEPOSIT_WITHDRAWALS_RESPONSE,
)
return response
def mock_poloniex_asset_return(url, *args): # pylint: disable=unused-argument
return MockResponse(200, POLONIEX_BALANCES_RESPONSE)
def mock_api_query_response(endpoint, method='', options=None): # pylint: disable=unused-argument # noqa: E501
return MockResponse(HTTPStatus.FORBIDDEN, '{"key"}')