def test_transfer_success_no_state_address2(self):
ACCOUNT_AMOUNT1 = 500
TRANSFER_VALUE = 200
signature = self.send_transaction(
AccountMethod.TRANSFER,
AccountClient.get_transfer_payload(self.account_address2,
TRANSFER_VALUE),
[self.account_address1, self.account_address2])
self.expect_get({
self.account_address1:
AccountClient.get_account_model(ACCOUNT_AMOUNT1),
self.account_address2:
None
})
self.expect_set(
signature, AccountMethod.TRANSFER, {
self.account_address1:
AccountClient.get_account_model(ACCOUNT_AMOUNT1 -
TRANSFER_VALUE),
self.account_address2:
AccountClient.get_account_model(0 + TRANSFER_VALUE)
})
self.expect_ok()
def transfer(self, address1, amount1, address2, amount2, value):
self.expect_get({address1: AccountClient.get_account_model(amount1)})
self.expect_get({address2: AccountClient.get_account_model(amount2)})
return {
address1: AccountClient.get_account_model(amount1 - value),
address2: AccountClient.get_account_model(amount2 + value)
}
def test_transfer_fail_no_balance(self):
ACCOUNT_AMOUNT1 = 200
ACCOUNT_AMOUNT2 = 500
TRANSFER_VALUE = ACCOUNT_AMOUNT1 + 1
self.send_transaction(AccountMethod.TRANSFER,
AccountClient.get_transfer_payload(self.account_address2, TRANSFER_VALUE),
[self.account_address1, self.account_address2])
self.expect_get({self.account_address1: AccountClient.get_account_model(ACCOUNT_AMOUNT1),
self.account_address2: AccountClient.get_account_model(ACCOUNT_AMOUNT2)})
self.expect_invalid_transaction()
def test_store_success(self):
context = self.get_context()
cert, key, _ = PubKeyClient.create_certificate(
context.pub_key_payload, signer=context.client.get_signer())
transaction_signature, cert_address, transaction_payload = self._pre_parse_payload_and_exec(
context, cert, key)
crt_export, crt_bin, crt_sig, rem_sig, pub_key, \
valid_from, valid_to = PubKeyClient.get_crt_export_bin_sig_rem_sig(cert, key, context.client)
account = AccountClient.get_account_model(PUB_KEY_STORE_PRICE)
storage_account = AccountClient.get_account_model(0)
storage_signer = self.get_new_signer()
storage_pub_key = storage_signer.get_public_key().as_hex()
storage_address = AccountHandler().make_address_from_data(
storage_pub_key)
data = PubKeyStorage()
data.owner = self.account_signer1.get_public_key().as_hex()
data.payload.CopyFrom(transaction_payload)
data.revoked = False
self.expect_get({cert_address: None, self.account_address1: account})
self.expect_get({_make_settings_key('remme.economy_enabled'): None})
self.expect_get({
_make_settings_key(SETTINGS_STORAGE_PUB_KEY):
get_setting_from_key_value(SETTINGS_STORAGE_PUB_KEY,
storage_pub_key)
})
self.expect_get({
self.account_address1: account,
storage_address: storage_account
})
context.client.store_pub_key(pub_key, rem_sig, crt_sig, valid_from,
valid_to)
account.balance -= PUB_KEY_STORE_PRICE
account.pub_keys.append(cert_address)
storage_account.balance += PUB_KEY_STORE_PRICE
self.expect_set(
transaction_signature, PubKeyMethod.STORE, {
self.account_address1: account,
cert_address: data,
storage_address: storage_account
})
self.expect_ok()
def test_swap_init_success(self):
# Bob init
context = self.get_context()
init_data = {
"receiver_address": self.account_address2,
"sender_address_non_local": context.sender_address_non_local,
"amount": context.AMOUNT,
"swap_id": context.swap_id,
"secret_lock_by_solicitor": context.secret_lock,
"email_address_encrypted_by_initiator": context.email_address,
"created_at": context.created_at,
}
context.client.swap_init(get_swap_init_payload(**init_data))
self.expect_get({context.swap_address: None})
self.expect_get({
_make_settings_key(SETTINGS_SWAP_COMMISSION):
get_setting_from_key_value(SETTINGS_SWAP_COMMISSION, context.COMMISSION)
})
TOTAL_TRANSFERED = context.AMOUNT+context.COMMISSION
self.expect_get({self.account_address1: AccountClient.get_account_model(TOTAL_TRANSFERED)})
updated_state = self.transfer(self.account_address1, TOTAL_TRANSFERED, ZERO_ADDRESS, 0, TOTAL_TRANSFERED)
context.swap_info.state = AtomicSwapInfo.OPENED
self.expect_set({
**{context.swap_address: context.swap_info},
**updated_state
})
self.expect_ok()
def test_store_success(self):
context = self.get_context()
cert, key, _ = create_certificate(context.pub_key_payload,
signer=context.client.get_signer())
cert_address, transaction_payload = self._pre_parse_payload_and_exec(
context, cert, key)
crt_export, crt_bin, crt_sig, rem_sig, pub_key, \
valid_from, valid_to = get_crt_export_bin_sig_rem_sig(cert, key, context.client)
account = AccountClient.get_account_model(PUB_KEY_STORE_PRICE)
data = PubKeyStorage()
data.owner = self.account_signer1.get_public_key().as_hex()
data.payload.CopyFrom(transaction_payload)
data.revoked = False
self.expect_get({cert_address: None, self.account_address1: account})
self.expect_get({_make_settings_key('remme.economy_enabled'): None})
context.client.store_pub_key(pub_key, rem_sig, crt_sig, valid_from,
valid_to)
account.balance -= PUB_KEY_STORE_PRICE
account.pub_keys.append(cert_address)
self.expect_set({self.account_address1: account, cert_address: data})
self.expect_ok()
def test_transfer_fail_no_state_address1(self):
ACCOUNT_AMOUNT2 = 500
TRANSFER_VALUE = 200
self.send_transaction(AccountMethod.TRANSFER,
AccountClient.get_transfer_payload(self.account_address2, TRANSFER_VALUE),
[self.account_address1, self.account_address2])
self.expect_get({self.account_address1: None, self.account_address2: AccountClient.get_account_model(0)})
self.expect_invalid_transaction()
def test_transfer_fail_to_zeroaddress(self):
ACCOUNT_AMOUNT1 = 500
TRANSFER_VALUE = 200
self.send_transaction(
AccountMethod.TRANSFER,
AccountClient.get_transfer_payload(GENESIS_ADDRESS,
TRANSFER_VALUE),
[self.account_address1, self.account_address2])
self.expect_get({
self.account_address1:
AccountClient.get_account_model(ACCOUNT_AMOUNT1)
})
self.expect_invalid_transaction()
def test_store_success(self):
context = self.get_context()
cert, key, _ = create_certificate(context.pub_key_payload, signer=context.client.get_signer())
cert_address, transaction_payload = self._pre_parse_payload_and_exec(context, cert, key)
self.expect_get({cert_address: None})
account = AccountClient.get_account_model(PUB_KEY_STORE_PRICE)
self.expect_get({self.account_address1: account})
data = PubKeyStorage()
data.owner = self.account_signer1.get_public_key().as_hex()
data.payload.CopyFrom(transaction_payload)
data.revoked = False
account.balance -= PUB_KEY_STORE_PRICE
account.pub_keys.append(cert_address)
self.expect_set({
self.account_address1: account,
cert_address: data
})
self.expect_ok()