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 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(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 create_wallet(client: ExonumClient, message_generator: MessageGenerator,
name: str) -> KeyPair:
"""Creates a wallet with the given name and returns a KeyPair for it."""
key_pair = KeyPair.generate()
# Load the "service.proto" from the Cryptocurrency service:
cryptocurrency_module = ModuleManager.import_service_module(
CRYPTOCURRENCY_ARTIFACT_NAME, "service")
# Create a Protobuf message:
create_wallet_message = cryptocurrency_module.TxCreateWallet()
create_wallet_message.name = name
# Convert the Protobuf message to an Exonum message and sign it:
create_wallet_tx = message_generator.create_message(create_wallet_message)
create_wallet_tx.sign(key_pair)
# Send the transaction to Exonum:
response = client.send_transaction(create_wallet_tx)
ensure_status_code(response)
tx_hash = response.json()["tx_hash"]
# Wait for new blocks:
with client.create_subscriber() as subscriber:
subscriber.wait_for_new_block()
subscriber.wait_for_new_block()
ensure_transaction_success(client, tx_hash)
print(f"Successfully created wallet with name '{name}'")
return key_pair
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_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 transfer(
client: ExonumClient, message_generator: MessageGenerator, from_keypair: KeyPair, to_key: PublicKey, amount: int
) -> Tuple[int, int]:
"""This example transfers tokens from one wallet to the other one and
returns the balances of these wallets."""
cryptocurrency_module = ModuleManager.import_service_module(CRYPTOCURRENCY_ARTIFACT_NAME, "service")
# Note that since we are using the Cryptocurrency module,
# we need to load helpers from this module and not from the main module:
helpers_module = ModuleManager.import_service_module(CRYPTOCURRENCY_ARTIFACT_NAME, "helpers")
transfer_message = cryptocurrency_module.Transfer()
transfer_message.to.CopyFrom(helpers_module.PublicKey(data=to_key.value))
transfer_message.amount = amount
transfer_message.seed = Seed.get_seed()
transfer_tx = message_generator.create_message(transfer_message)
transfer_tx.sign(from_keypair)
response = client.send_transaction(transfer_tx)
ensure_status_code(response)
tx_hash = response.json()["tx_hash"]
# Wait for new blocks:
with client.create_subscriber() as subscriber:
subscriber.wait_for_new_block()
subscriber.wait_for_new_block()
ensure_transaction_success(client, tx_hash)
from_balance = get_balance(client, from_keypair.public_key)
to_balance = get_balance(client, to_key)
return from_balance, to_balance
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_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_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_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 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 transfer(client: ExonumClient, message_generator: MessageGenerator,
from_keypair: KeyPair, to_key: PublicKey,
amount: int) -> Tuple[int, int]:
"""This example transfers tokens from one wallet to the other one and
returns the balances of these wallets."""
cryptocurrency_module = ModuleManager.import_service_module(
CRYPTOCURRENCY_ARTIFACT_NAME, CRYPTOCURRENCY_ARTIFACT_VERSION,
"service")
# Note that since we are using the Cryptocurrency module,
# we need to load types from this module and not from the main module:
types_module = ModuleManager.import_service_module(
CRYPTOCURRENCY_ARTIFACT_NAME, CRYPTOCURRENCY_ARTIFACT_VERSION,
"exonum.crypto.types")
transfer_message = cryptocurrency_module.Transfer()
# The address is a hash of a `Caller` protobuf message.
hash_address = message_generator.pk_to_hash_address(to_key)
if hash_address is None:
raise Exception
transfer_message.to.CopyFrom(types_module.Hash(data=hash_address.value))
transfer_message.amount = amount
transfer_message.seed = Seed.get_seed()
transfer_tx = message_generator.create_message(transfer_message)
transfer_tx.sign(from_keypair)
response = client.public_api.send_transaction(transfer_tx)
ensure_status_code(response)
tx_hash = response.json()["tx_hash"]
# Wait for new blocks:
with client.create_subscriber("blocks") as subscriber:
subscriber.wait_for_new_event()
subscriber.wait_for_new_event()
ensure_transaction_success(client, tx_hash)
from_balance = get_balance(client, from_keypair.public_key)
to_balance = get_balance(client, to_key)
return from_balance, to_balance
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 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)
