def test_user_agent(self):
"""Tests the `user_agent` endpoint."""
for validator_id in range(self.network.validators_count()):
host, public_port, private_port = self.network.api_address(
validator_id)
client = vegaClient(host, public_port, private_port)
user_agent_response = client.public_api.user_agent()
self.assertEqual(user_agent_response.status_code, 200)
def wait_for_block(network: vegaNetwork, height: int = 1) -> None:
"""Wait for block at specific height"""
for validator_id in range(network.validators_count()):
host, public_port, private_port = network.api_address(validator_id)
client = vegaClient(host, public_port, private_port)
for _ in range(RETRIES_AMOUNT):
if client.public_api.get_block(height).status_code == 200:
break
time.sleep(0.5)
def test_zero_block(self):
"""Tests the `block` endpoint. Check response for 0 block"""
for validator_id in range(self.network.validators_count()):
host, public_port, private_port = self.network.api_address(
validator_id)
client = vegaClient(host, public_port, private_port)
block_response = client.public_api.get_block(0)
self.assertEqual(block_response.status_code, 200)
self.assertEqual(block_response.json()['height'], 0)
def test_nonexistent_block(self):
"""Tests the `block` endpoint. Check response for nonexistent block"""
nonexistent_height = 999
for validator_id in range(self.network.validators_count()):
host, public_port, private_port = self.network.api_address(
validator_id)
client = vegaClient(host, public_port, private_port)
block_response = client.public_api.get_block(nonexistent_height)
self.assertEqual(block_response.status_code, 404)
def test_get_nonexistent_wallet(self):
"""Tests the wallet history is None for nonexistent wallet"""
for validator_id in range(self.network.validators_count()):
host, public_port, private_port = self.network.api_address(validator_id)
client = vegaClient(host, public_port, private_port)
with vegaCryptoAdvancedClient(client) as crypto_client:
alice_keys = KeyPair.generate()
wallet_history = crypto_client.get_wallet_info(alice_keys).json()["wallet_history"]
self.assertIsNone(wallet_history)
def test_get_only_non_empty_blocks(self):
"""Tests the `blocks` endpoint. Check response for only non empty blocks"""
for validator_id in range(self.network.validators_count()):
host, public_port, private_port = self.network.api_address(
validator_id)
client = vegaClient(host, public_port, private_port)
blocks_response = client.public_api.get_blocks(
count=5, skip_empty_blocks=True)
self.assertEqual(blocks_response.status_code, 200)
self.assertEqual(len(blocks_response.json()['blocks']), 0)
def wait_api_to_start(network: vegaNetwork) -> None:
"""Wait for api starting"""
for validator_id in range(network.validators_count()):
host, public_port, private_port = network.api_address(validator_id)
client = vegaClient(host, public_port, private_port)
for _ in range(RETRIES_AMOUNT):
try:
client.public_api.health_info()
break
except ConnectionError:
time.sleep(0.5)
def test_get_blocks_with_time(self):
"""Tests the `blocks` endpoint. Check response for blocks with time"""
for validator_id in range(self.network.validators_count()):
host, public_port, private_port = self.network.api_address(
validator_id)
client = vegaClient(host, public_port, private_port)
blocks_response = client.public_api.get_blocks(
count=1, add_blocks_time=True)
self.assertEqual(blocks_response.status_code, 200)
self.assertIsNotNone(blocks_response.json()['blocks'][0]['time'])
def test_get_n_latest_blocks_negative(self):
"""Tests the `blocks` endpoint. Check response for N latest blocks if latest exceeds current height"""
latest = 999
number_of_blocks = 6
for validator_id in range(self.network.validators_count()):
host, public_port, private_port = self.network.api_address(
validator_id)
client = vegaClient(host, public_port, private_port)
blocks_response = client.public_api.get_blocks(
count=number_of_blocks, latest=latest)
self.assertEqual(blocks_response.status_code, 404)
def test_zero_initial_stats(self):
"""Tests the `stats` endpoint. Check initial stats values"""
for validator_id in range(self.network.validators_count()):
host, public_port, private_port = self.network.api_address(
validator_id)
client = vegaClient(host, public_port, private_port)
stats = client.public_api.stats()
self.assertEqual(stats.status_code, 200)
self.assertEqual(stats.json()['tx_count'], 0)
self.assertEqual(stats.json()['tx_pool_size'], 0)
self.assertEqual(stats.json()['tx_cache_size'], 0)
def test_health_check(self):
"""Tests the `healthcheck` endpoint."""
time.sleep(10)
for validator_id in range(self.network.validators_count()):
host, public_port, private_port = self.network.api_address(
validator_id)
client = vegaClient(host, public_port, private_port)
health_info_response = client.public_api.health_info()
self.assertEqual(health_info_response.status_code, 200)
self.assertEqual(health_info_response.json()['connected_peers'],
self.network.validators_count() - 1)
self.assertEqual(health_info_response.json()['consensus_status'],
'Active')
def test_add_funds_to_nonexistent_wallet(self):
"""Tests the funds issue is failed if wallet doesn't exist"""
for validator_id in range(self.network.validators_count()):
host, public_port, private_port = self.network.api_address(validator_id)
client = vegaClient(host, public_port, private_port)
with vegaCryptoAdvancedClient(client) as crypto_client:
alice_keys = KeyPair.generate()
tx_response = crypto_client.issue(alice_keys, 100)
with client.create_subscriber("transactions") as subscriber:
subscriber.wait_for_new_event()
tx_info = client.public_api.get_tx_info(tx_response.json()["tx_hash"]).json()
tx_status = tx_info["status"]["type"]
self.assertEqual(tx_status, "service_error")
def test_get_last_n_blocks(self):
"""Tests the `blocks` endpoint. Check response for last N blocks"""
number_of_blocks = 5
wait_for_block(self.network, 5)
for validator_id in range(self.network.validators_count()):
host, public_port, private_port = self.network.api_address(
validator_id)
client = vegaClient(host, public_port, private_port)
blocks_response = client.public_api.get_blocks(
count=number_of_blocks)
self.assertEqual(blocks_response.status_code, 200)
self.assertEqual(len(blocks_response.json()['blocks']),
number_of_blocks)
def test_get_unknown_transaction(self):
"""Tests the `transactions` endpoint. Check response for unknown transaction"""
for validator_id in range(self.network.validators_count()):
host, public_port, private_port = self.network.api_address(
validator_id)
client = vegaClient(host, public_port, private_port)
tx_response = client.public_api.get_tx_info(
"b2d09e1bddca851bee8faf8ffdcfc18cb87fbde167a29bd049fa2eee4a82c1ca"
)
self.assertEqual(tx_response.status_code, 404)
response_info = tx_response.json()
self.assertEqual(response_info["title"],
"Failed to get transaction info")
self.assertEqual(response_info["detail"], r'{"type":"unknown"}')
def test_token_issue(self):
"""Tests the token issue"""
for validator_id in range(self.network.validators_count()):
host, public_port, private_port = self.network.api_address(validator_id)
client = vegaClient(host, public_port, private_port)
with vegaCryptoAdvancedClient(client) as crypto_client:
alice_keys = KeyPair.generate()
crypto_client.create_wallet(alice_keys, "Alice" + str(validator_id))
with client.create_subscriber("transactions") as subscriber:
subscriber.wait_for_new_event()
crypto_client.issue(alice_keys, 100)
subscriber.wait_for_new_event()
alice_balance = crypto_client.get_balance(alice_keys)
self.assertEqual(alice_balance, 200)
def test_create_wallet_same_name(self):
"""Tests the transaction with the same wallet name is rejected"""
client = None
for validator_id in range(self.network.validators_count()):
host, public_port, private_port = self.network.api_address(validator_id)
client = vegaClient(host, public_port, private_port)
with vegaCryptoAdvancedClient(client) as crypto_client:
alice_keys = KeyPair.generate()
crypto_client.create_wallet(alice_keys, "Alice" + str(validator_id))
with client.create_subscriber("transactions") as subscriber:
subscriber.wait_for_new_event()
# create the wallet with the same name again
crypto_client.create_wallet(alice_keys, "Alice" + str(validator_id))
with client.create_subscriber("blocks") as subscriber:
subscriber.wait_for_new_event()
# it should contain 4 txs for wallet creation plus 6 services txs
self.assertEqual(client.public_api.stats().json()["tx_count"], 10)
def test_get_n_latest_blocks(self):
"""Tests the `blocks` endpoint. Check response for N latest blocks"""
latest = 5
number_of_blocks = 15
wait_for_block(self.network, 5)
for validator_id in range(self.network.validators_count()):
height_counter = latest
host, public_port, private_port = self.network.api_address(
validator_id)
client = vegaClient(host, public_port, private_port)
blocks_response = client.public_api.get_blocks(
count=number_of_blocks, latest=latest)
self.assertEqual(len(blocks_response.json()['blocks']), latest + 1)
for block in blocks_response.json()['blocks']:
self.assertEqual(int(block['height']), height_counter)
height_counter -= 1
def test_transfer_funds(self):
"""Tests the transfer funds to another wallet"""
for validator_id in range(self.network.validators_count()):
host, public_port, private_port = self.network.api_address(validator_id)
client = vegaClient(host, public_port, private_port)
with vegaCryptoAdvancedClient(client) as crypto_client:
alice_keys = KeyPair.generate()
bob_keys = KeyPair.generate()
with client.create_subscriber("transactions") as subscriber:
crypto_client.create_wallet(alice_keys, "Alice" + str(validator_id))
subscriber.wait_for_new_event()
crypto_client.create_wallet(bob_keys, "Bob" + str(validator_id))
subscriber.wait_for_new_event()
crypto_client.transfer(20, alice_keys, bob_keys.public_key)
subscriber.wait_for_new_event()
alice_balance = crypto_client.get_balance(alice_keys)
bob_balance = crypto_client.get_balance(bob_keys)
self.assertEqual(alice_balance, 80)
self.assertEqual(bob_balance, 120)
def test_get_n_earliest_blocks(self):
"""Tests the `blocks` endpoint. Check response for N earliest blocks"""
earliest = 20
number_of_blocks = 15
wait_for_block(self.network, 20)
for validator_id in range(self.network.validators_count()):
height_counter = earliest
host, public_port, private_port = self.network.api_address(
validator_id)
client = vegaClient(host, public_port, private_port)
blocks_response = client.public_api.get_blocks(
count=number_of_blocks, earliest=earliest)
latest_height = int(blocks_response.json()['blocks'][0]['height'])
self.assertEqual(len(blocks_response.json()['blocks']),
latest_height - earliest + 1)
# blocks must be started from 'earliest' height
for block in reversed(blocks_response.json()['blocks']):
self.assertEqual(int(block['height']), height_counter)
height_counter += 1
def test_create_wallet_unique_for_key_pair(self):
"""Tests the transaction with the same keys for different wallets is failed"""
for validator_id in range(self.network.validators_count()):
host, public_port, private_port = self.network.api_address(validator_id)
client = vegaClient(host, public_port, private_port)
with vegaCryptoAdvancedClient(client) as crypto_client:
alice_keys = KeyPair.generate()
tx_response = crypto_client.create_wallet(
alice_keys, "Alice" + str(validator_id)
)
with client.create_subscriber("transactions") as subscriber:
subscriber.wait_for_new_event()
tx_status = client.public_api.get_tx_info(tx_response.json()["tx_hash"]).json()["status"]["type"]
self.assertEqual(tx_status, "success")
# create the wallet with the same keys again
tx_same_keys = crypto_client.create_wallet(
alice_keys, "Alice_Dublicate" + str(validator_id)
)
with client.create_subscriber("blocks") as subscriber:
subscriber.wait_for_new_event()
tx_status = client.public_api.get_tx_info(tx_same_keys.json()["tx_hash"]).json()["status"]["type"]
self.assertEqual(tx_status, "service_error")
def test_transfer_funds_insufficient(self):
"""Tests the transfer insufficient amount of funds is failed"""
for validator_id in range(self.network.validators_count()):
host, public_port, private_port = self.network.api_address(validator_id)
client = vegaClient(host, public_port, private_port)
with vegaCryptoAdvancedClient(client) as crypto_client:
alice_keys = KeyPair.generate()
crypto_client.create_wallet(alice_keys, "Alice" + str(validator_id))
bob_keys = KeyPair.generate()
crypto_client.create_wallet(bob_keys, "Bob" + str(validator_id))
with client.create_subscriber("blocks") as subscriber:
subscriber.wait_for_new_event()
tx_response = crypto_client.transfer(
110, alice_keys, bob_keys.public_key
)
subscriber.wait_for_new_event()
tx_info = client.public_api.get_tx_info(tx_response.json()["tx_hash"]).json()
tx_status = tx_info["status"]["type"]
self.assertEqual(tx_status, "service_error")
alice_balance = crypto_client.get_balance(alice_keys)
bob_balance = crypto_client.get_balance(bob_keys)
self.assertEqual(alice_balance, 100)
self.assertEqual(bob_balance, 100)
def test_deploy_regular_with_consensus_config(self):
"""Tests the deploy mechanism in regular mode with consensus config."""
pub_configs = self.network._public_configs().split()
validator_keys = []
for pub_config in pub_configs:
keys = []
with open(pub_config, 'r') as file:
data = file.read()
keys.append(
re.search('consensus_key = "(.+?)"', data).group(1))
keys.append(re.search('service_key = "(.+?)"', data).group(1))
validator_keys.append(keys)
cryptocurrency_advanced_config_dict = {
"networks": launcher_networks(self.network),
"deadline_height": 10000,
"consensus": {
"validator_keys": validator_keys,
"first_round_timeout": 3000,
"status_timeout": 5000,
"peers_timeout": 10000,
"txs_block_limit": 5000,
"max_message_len": 1048576,
"min_propose_timeout": 10,
"max_propose_timeout": 200,
"propose_timeout_threshold": 500
},
"artifacts": {
"cryptocurrency": {
"runtime": "rust",
"name": "vega-cryptocurrency-advanced",
"version": "0.1.0",
}
},
"instances": {
"crypto": {
"artifact": "cryptocurrency"
}
},
}
cryptocurrency_advanced_config = Configuration(
cryptocurrency_advanced_config_dict)
with Launcher(cryptocurrency_advanced_config) as launcher:
explorer = launcher.explorer()
launcher.deploy_all()
launcher.wait_for_deploy()
launcher.start_all()
launcher.wait_for_start()
for artifact in launcher.launch_state.completed_deployments():
deployed = explorer.check_deployed(artifact)
self.assertEqual(deployed, True)
self.assertEqual(len(launcher.launch_state.completed_configs()), 1)
for validator_id in range(self.network.validators_count()):
host, public_port, private_port = self.network.api_address(
validator_id)
client = vegaClient(host, public_port, private_port)
supervisor_api = client.service_apis("supervisor")
consensus_config = supervisor_api[0].get_service(
"consensus-config").json()
# check that initial config has been applied
self.assertEqual(consensus_config['txs_block_limit'], 5000)
def test_deploy_regular_stop_running_instance(self):
"""Tests the deploy mechanism to stop running instance."""
cryptocurrency_advanced_config_dict = {
"networks": launcher_networks(self.network),
"deadline_height": 10000,
"artifacts": {
"cryptocurrency": {
"runtime": "rust",
"name": "vega-cryptocurrency-advanced",
"version": "0.1.0",
}
},
"instances": {
"crypto": {
"artifact": "cryptocurrency"
}
},
}
cryptocurrency_advanced_config = Configuration(
cryptocurrency_advanced_config_dict)
with Launcher(cryptocurrency_advanced_config) as launcher:
explorer = launcher.explorer()
launcher.deploy_all()
launcher.wait_for_deploy()
launcher.start_all()
launcher.wait_for_start()
for artifact in launcher.launch_state.completed_deployments():
deployed = explorer.check_deployed(artifact)
self.assertEqual(deployed, True)
self.assertEqual(len(launcher.launch_state.completed_configs()), 1)
# stop service
cryptocurrency_advanced_config_dict = {
"networks": launcher_networks(self.network),
"deadline_height": 10000,
"artifacts": {
"cryptocurrency": {
"runtime": "rust",
"name": "vega-cryptocurrency-advanced",
"version": "0.1.0",
}
},
"instances": {
"crypto": {
"artifact": "cryptocurrency",
"action": "stop"
}
},
}
cryptocurrency_advanced_config = Configuration(
cryptocurrency_advanced_config_dict)
with Launcher(cryptocurrency_advanced_config) as launcher:
launcher.deploy_all()
launcher.wait_for_deploy()
launcher.start_all()
launcher.wait_for_start()
for validator_id in range(self.network.validators_count()):
host, public_port, private_port = self.network.api_address(
validator_id)
client = vegaClient(host, public_port, private_port)
available_services = client.public_api.available_services().json()
# crypto instance always first element in array
self.assertEqual(
available_services['services'][0]['status']['type'], 'stopped')
with vegaCryptoAdvancedClient(client) as crypto_client:
alice_keys = KeyPair.generate()
tx_response = crypto_client.create_wallet(
alice_keys, "Alice" + str(validator_id))
# in case of stopped service its tx will not be processed
self.assertEqual(tx_response.status_code, 400)
self.assertIn("Specified service is not active",
str(tx_response.content))
