def test_freeze_service(self):
host, public_port, private_port = self.network.api_address(0)
client = ExonumClient(host, public_port, private_port)
# Create wallet
alice_keys = KeyPair.generate()
with ExonumCryptoAdvancedClient(client) as crypto_client:
crypto_client.create_wallet(alice_keys, "Alice")
with client.create_subscriber("transactions") as subscriber:
subscriber.wait_for_new_event()
alice_balance = crypto_client.get_balance(alice_keys)
self.assertEqual(alice_balance, 100)
# Freeze the service
instances = {
"crypto": {
"artifact": "cryptocurrency",
"action": "freeze"
}
}
cryptocurrency_advanced_config_dict = generate_config(
self.network, instances=instances, artifact_action="none")
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()
# Check that the service status has been changed to `frozen`.
for service in client.public_api.available_services().json(
)["services"]:
if service["spec"]["name"] == "crypto":
self.assertEqual(service["status"]["type"], "frozen")
# Try to create a new wallet. The operation should fail.
with ExonumCryptoAdvancedClient(client) as crypto_client:
bob_keys = KeyPair.generate()
response = crypto_client.create_wallet(bob_keys, "Bob")
self.assertEqual(response.status_code, 400)
# Because the service is frozen, transaction should be inadmissible.
self.assertEqual(response.json()["title"],
"Failed to add transaction to memory pool")
# Check that we can use service endpoints for data retrieving. Check wallet once again.
with ExonumCryptoAdvancedClient(client) as crypto_client:
alice_balance = crypto_client.get_balance(alice_keys)
self.assertEqual(alice_balance, 100)
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 = ExonumClient(host, public_port, private_port)
with ExonumCryptoAdvancedClient(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.value)
subscriber.wait_for_new_event()
tx_status = client.get_tx_info(
tx_response.json()['tx_hash']).json()['status']['type']
self.assertEqual(tx_status, 'service_error')
alice_balance = (crypto_client.get_wallet_info(
alice_keys).json()['wallet_proof']['to_wallet']
['entries'][0]['value']['balance'])
bob_balance = (crypto_client.get_wallet_info(
bob_keys).json()['wallet_proof']['to_wallet']
['entries'][0]['value']['balance'])
self.assertEqual(alice_balance, 100)
self.assertEqual(bob_balance, 100)
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 = ExonumClient(host, public_port, private_port)
with ExonumCryptoAdvancedClient(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()
# TODO: Sometimes it fails without time.sleep() [ECR-3876]
time.sleep(2)
crypto_client.transfer(20, alice_keys,
bob_keys.public_key.value)
subscriber.wait_for_new_event()
# TODO: Sometimes it fails without time.sleep() [ECR-3876]
time.sleep(2)
alice_balance = (crypto_client.get_wallet_info(
alice_keys).json()['wallet_proof']['to_wallet']
['entries'][0]['value']['balance'])
bob_balance = (crypto_client.get_wallet_info(
bob_keys).json()['wallet_proof']['to_wallet']
['entries'][0]['value']['balance'])
self.assertEqual(alice_balance, 80)
self.assertEqual(bob_balance, 120)
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 = ExonumClient(host, public_port, private_port)
with ExonumCryptoAdvancedClient(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.value)
subscriber.wait_for_new_event()
alice_wallet = crypto_client.get_wallet_info(
alice_keys).json()
alice_balance = alice_wallet["wallet_proof"]["to_wallet"][
"entries"][0]["value"]["balance"]
bob_wallet = crypto_client.get_wallet_info(bob_keys).json()
bob_balance = bob_wallet["wallet_proof"]["to_wallet"][
"entries"][0]["value"]["balance"]
self.assertEqual(alice_balance, 80)
self.assertEqual(bob_balance, 120)
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 = ExonumClient(host, public_port, private_port)
with ExonumCryptoAdvancedClient(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_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 = ExonumClient(host, public_port, private_port)
with ExonumCryptoAdvancedClient(client) as crypto_client:
alice_keys = KeyPair.generate()
tx_response = crypto_client.create_wallet(
alice_keys, "Alice" + str(validator_id))
with client.create_subscriber("blocks") as subscriber:
subscriber.wait_for_new_event()
# TODO: Sometimes it fails without time.sleep() [ECR-3876]
time.sleep(2)
tx_status = client.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.get_tx_info(
tx_same_keys.json()['tx_hash']).json()['status']['type']
self.assertEqual(tx_status, 'service_error')
def _create_wallet(self, client: ExonumClient, wallet_name: str,
version: str) -> KeyPair:
with ExonumCryptoAdvancedClient(client, INSTANCE_NAME,
version) as crypto_client:
keys = KeyPair.generate()
response = crypto_client.create_wallet(keys, wallet_name)
self.assertEqual(response.status_code, 200)
with client.create_subscriber("transactions") as subscriber:
subscriber.wait_for_new_event()
return keys
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 = ExonumClient(host, public_port, private_port)
with ExonumCryptoAdvancedClient(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_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 = ExonumClient(host, public_port, private_port)
with ExonumCryptoAdvancedClient(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_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 = ExonumClient(host, public_port, private_port)
with ExonumCryptoAdvancedClient(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_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 = ExonumClient(host, public_port, private_port)
with ExonumCryptoAdvancedClient(client) as crypto_client:
alice_keys = KeyPair.generate()
tx_response = crypto_client.issue(alice_keys, 100)
with client.create_subscriber("blocks") as subscriber:
subscriber.wait_for_new_event()
# TODO: Sometimes it fails without time.sleep() [ECR-3876]
time.sleep(2)
tx_status = client.get_tx_info(
tx_response.json()['tx_hash']).json()['status']['type']
self.assertEqual(tx_status, 'service_error')
def test_create_wallet(self):
"""Tests the wallet creation"""
for validator_id in range(self.network.validators_count()):
host, public_port, private_port = self.network.api_address(
validator_id)
client = ExonumClient(host, public_port, private_port)
with ExonumCryptoAdvancedClient(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()
self.assertEqual(
crypto_client.get_wallet_info(alice_keys).status_code, 200)
alice_wallet = crypto_client.get_wallet_info(alice_keys).json()
alice_balance = alice_wallet["wallet_proof"]["to_wallet"][
"entries"][0]["value"]["balance"]
self.assertEqual(alice_balance, 100)
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 = ExonumClient(host, public_port, private_port)
with ExonumCryptoAdvancedClient(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_transfer_to_yourself(self):
"""Tests the transfer funds to yourself is impossible"""
for validator_id in range(self.network.validators_count()):
host, public_port, private_port = self.network.api_address(
validator_id)
client = ExonumClient(host, public_port, private_port)
with ExonumCryptoAdvancedClient(client) as crypto_client:
alice_keys = KeyPair.generate()
crypto_client.create_wallet(alice_keys,
"Alice" + str(validator_id))
with client.create_subscriber("blocks") as subscriber:
subscriber.wait_for_new_event()
crypto_client.transfer(10, alice_keys,
alice_keys.public_key.value)
subscriber.wait_for_new_event()
alice_balance = (crypto_client.get_wallet_info(
alice_keys).json()['wallet_proof']['to_wallet']
['entries'][0]['value']['balance'])
self.assertEqual(alice_balance, 100)
def test_create_wallet(self):
"""Tests the wallet creation"""
for validator_id in range(self.network.validators_count()):
host, public_port, private_port = self.network.api_address(
validator_id)
client = ExonumClient(host, public_port, private_port)
with ExonumCryptoAdvancedClient(client) as crypto_client:
alice_keys = KeyPair.generate()
crypto_client.create_wallet(alice_keys,
"Alice" + str(validator_id))
with client.create_subscriber("blocks") as subscriber:
subscriber.wait_for_new_event()
self.assertEqual(
crypto_client.get_wallet_info(alice_keys).status_code, 200)
# TODO: Sometimes it fails without time.sleep() [ECR-3876]
time.sleep(2)
alice_balance = (crypto_client.get_wallet_info(
alice_keys).json()['wallet_proof']['to_wallet']['entries']
[0]['value']['balance'])
self.assertEqual(alice_balance, 100)
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 = ExonumClient(host, public_port, private_port)
with ExonumCryptoAdvancedClient(client) as crypto_client:
alice_keys = KeyPair.generate()
crypto_client.create_wallet(alice_keys,
"Alice" + str(validator_id))
with client.create_subscriber("blocks") as subscriber:
subscriber.wait_for_new_event()
# TODO: Sometimes it fails without time.sleep() [ECR-3876]
time.sleep(2)
crypto_client.issue(alice_keys, 100)
subscriber.wait_for_new_event()
# TODO: Sometimes it fails without time.sleep() [ECR-3876]
time.sleep(2)
alice_wallet = crypto_client.get_wallet_info(
alice_keys).json()
alice_balance = alice_wallet["wallet_proof"]["to_wallet"][
"entries"][0]["value"]["balance"]
self.assertEqual(alice_balance, 200)
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 = ExonumClient(host, public_port, private_port)
with ExonumCryptoAdvancedClient(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 full_migration_flow(self, action: str):
host, public_port, private_port = self.network.api_address(0)
client = ExonumClient(host, public_port, private_port)
# Deploy a service with 0.2.0 version.
instances = {INSTANCE_NAME: {"artifact": "cryptocurrency"}}
config_dict = generate_config(self.network, instances=instances)
deploy_config = Configuration(config_dict)
with Launcher(deploy_config) as launcher:
launcher.deploy_all()
launcher.wait_for_deploy()
self.wait_for_api_restart()
explorer = launcher.explorer()
for artifact in launcher.launch_state.completed_deployments():
deployed = explorer.is_deployed(artifact)
self.assertTrue(deployed)
# Create Alice's wallet with 0.1.0 version of the service
alice_keys = self._create_wallet(client, "Alice", "0.1.0")
# Stop the working service with version 0.1.0.
instances = {
INSTANCE_NAME: {
"artifact": "cryptocurrency",
"action": action
}
}
stop_config_dict = generate_config(self.network,
instances=instances,
artifact_action="none",
artifact_version="0.1.0")
stop_config = Configuration(stop_config_dict)
with Launcher(stop_config) as launcher:
launcher.start_all()
launcher.wait_for_start()
self.wait_for_api_restart()
# Check that the service status has been changed to `stopped`.
for service in client.public_api.available_services().json(
)["services"]:
if service["spec"]["name"] == INSTANCE_NAME:
self.assertEqual(
service["status"]["type"],
"stopped" if action == "stop" else "frozen")
# Migrate service data from 0.1.0 to 0.2.0 version
migrations = {
INSTANCE_NAME: {
"runtime": "rust",
"name": "exonum-cryptocurrency",
"version": "0.2.0"
}
}
migrations_dict = generate_migration_config(self.network, migrations)
migration_config = Configuration(migrations_dict)
with Launcher(migration_config) as launcher:
launcher.migrate_all()
launcher.wait_for_migration()
for service in client.public_api.available_services().json(
)["services"]:
if service["spec"]["name"] == INSTANCE_NAME:
self.assertEqual(service["data_version"], "0.2.0")
# Switch service artifact from 0.1.0 to 0.2.0 version
with Launcher(migration_config) as launcher:
launcher.migrate_all()
launcher.wait_for_migration()
for service in client.public_api.available_services().json(
)["services"]:
if service["spec"]["name"] == INSTANCE_NAME:
self.assertEqual(service["spec"]["artifact"]["version"],
"0.2.0")
# Resume service with a new logic version 0.2.0
instances = {
INSTANCE_NAME: {
"artifact": "cryptocurrency",
"action": "resume"
}
}
resume_config_dict = generate_config(self.network,
instances=instances,
artifact_action="none")
resume_config = Configuration(resume_config_dict)
with Launcher(resume_config) as launcher:
launcher.start_all()
launcher.wait_for_start()
self.wait_for_api_restart()
# Check that the service status has been changed to `active`.
for service in client.public_api.available_services().json(
)["services"]:
if service["spec"]["name"] == INSTANCE_NAME:
self.assertEqual(service["status"]["type"], "active")
self.assertEqual(service["spec"]["artifact"]["version"],
"0.2.0")
# Unload artifact with version 0.1.0
unload_config_dict = generate_config(self.network,
instances=instances,
artifact_action="unload",
artifact_version="0.1.0")
unload_config = Configuration(unload_config_dict)
with Launcher(unload_config) as launcher:
launcher.unload_all()
launcher.wait_for_unload()
self.wait_for_api_restart()
explorer = launcher.explorer()
for artifact in unload_config.artifacts.values():
deployed = explorer.is_deployed(artifact)
self.assertFalse(deployed)
# Create Bob's wallet with version 0.2.0 of the service.
bob_keys = self._create_wallet(client, "Bob", "0.2.0")
# Transfer some coins and check balances and history length.
with ExonumCryptoAdvancedClient(
client, instance_name=INSTANCE_NAME) as crypto_client:
alice_balance = crypto_client.get_balance(alice_keys)
self.assertEqual(alice_balance, 100)
alice_history_len = crypto_client.get_history_len(alice_keys)
self.assertEqual(alice_history_len, 0)
bob_balance = crypto_client.get_balance(bob_keys)
self.assertEqual(bob_balance, 100)
crypto_client.transfer(20, alice_keys, bob_keys.public_key)
with client.create_subscriber("transactions") as subscriber:
subscriber.wait_for_new_event()
alice_balance = crypto_client.get_balance(alice_keys)
self.assertEqual(alice_balance, 80)
# Get a value from the new field `history_len`.
alice_history_len = crypto_client.get_history_len(alice_keys)
self.assertEqual(alice_history_len, 1)
bob_balance = crypto_client.get_balance(bob_keys)
self.assertEqual(bob_balance, 120)
def test_resume_after_freeze_service(self):
host, public_port, private_port = self.network.api_address(0)
client = ExonumClient(host, public_port, private_port)
# Create wallet
with ExonumCryptoAdvancedClient(client) as crypto_client:
alice_keys = KeyPair.generate()
crypto_client.create_wallet(alice_keys, "Alice")
with client.create_subscriber("transactions") as subscriber:
subscriber.wait_for_new_event()
alice_balance = crypto_client.get_balance(alice_keys)
self.assertEqual(alice_balance, 100)
# Freeze the service
instances = {
"crypto": {
"artifact": "cryptocurrency",
"action": "freeze"
}
}
cryptocurrency_advanced_config_dict = generate_config(
self.network, instances=instances, artifact_action="none")
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()
# Resume the service
instances = {
"crypto": {
"artifact": "cryptocurrency",
"action": "resume"
}
}
cryptocurrency_advanced_config_dict = generate_config(
self.network, instances=instances, artifact_action="none")
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()
# Check that the service status has been changed to `active`.
for service in client.public_api.available_services().json(
)["services"]:
if service["spec"]["name"] == "crypto":
self.assertEqual(service["status"]["type"], "active")
# Check that an ability to create wallets has been restored.
with ExonumCryptoAdvancedClient(client) as crypto_client:
bob_keys = KeyPair.generate()
crypto_client.create_wallet(bob_keys, "Bob")
with client.create_subscriber("transactions") as subscriber:
subscriber.wait_for_new_event()
bob_balance = crypto_client.get_balance(bob_keys)
self.assertEqual(bob_balance, 100)
def test_deploy_regular_stop_and_resume_running_instance(self):
"""Tests the deploy mechanism to stop
and resume running instance."""
instances = {"crypto": {"artifact": "cryptocurrency"}}
cryptocurrency_advanced_config_dict = generate_config(self.network, instances=instances)
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()
self.wait_for_api_restart()
for artifact in launcher.launch_state.completed_deployments():
deployed = explorer.is_deployed(artifact)
self.assertEqual(deployed, True)
self.assertEqual(len(launcher.launch_state.completed_configs()), 1)
# stop service
instances = {"crypto": {"artifact": "cryptocurrency", "action": "stop"}}
cryptocurrency_advanced_config_dict = generate_config(self.network, instances=instances, artifact_action="none")
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()
# The changes restart the HTTP servers of the nodes, so we wait for the servers to restart.
wait_network_to_start(self.network)
for validator_id in range(self.network.validators_count()):
host, public_port, private_port = self.network.api_address(validator_id)
client = ExonumClient(host, public_port, private_port)
available_services = client.public_api.available_services().json()
service_status = find_service_status(available_services, "crypto")
self.assertEqual(service_status, "stopped")
with ExonumCryptoAdvancedClient(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("Cannot dispatch transaction to non-active service", str(tx_response.content))
# resume service
instances = {"crypto": {"artifact": "cryptocurrency", "action": "resume"}}
cryptocurrency_advanced_config_dict = generate_config(self.network, instances=instances, artifact_action="none")
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()
# The changes restart the HTTP servers of the nodes, so we wait for the servers to restart.
self.wait_for_api_restart()
for validator_id in range(self.network.validators_count()):
host, public_port, private_port = self.network.api_address(validator_id)
client = ExonumClient(host, public_port, private_port)
available_services = client.public_api.available_services().json()
service_status = find_service_status(available_services, "crypto")
self.assertEqual(service_status, "active")
with ExonumCryptoAdvancedClient(client) as crypto_client:
alice_keys = KeyPair.generate()
tx_response = crypto_client.create_wallet(alice_keys, "Alice" + str(validator_id))
# resumed service must process txs as usual
self.assertEqual(tx_response.status_code, 200)
