def setUp(self):
super().setUp()
self.task_to_compute = self._get_deserialized_task_to_compute()
self.subtask = store_subtask(
task_id=self.task_to_compute.task_id,
subtask_id=self.task_to_compute.subtask_id,
provider_public_key=self.PROVIDER_PUBLIC_KEY,
requestor_public_key=self.REQUESTOR_PUBLIC_KEY,
state=Subtask.SubtaskState.ACCEPTED,
next_deadline=None,
task_to_compute=self.task_to_compute,
report_computed_task=factories.tasks.ReportComputedTaskFactory(
task_to_compute=self.task_to_compute))
self.subtask.full_clean()
self.subtask.save()
self.deposit_account = DepositAccount()
self.deposit_account.client = self.subtask.requestor
self.deposit_account.ethereum_address = self.task_to_compute.requestor_ethereum_address
self.deposit_account.clean()
self.deposit_account.save()
self.deposit_claim = DepositClaim()
self.deposit_claim.subtask_id = self.task_to_compute.subtask_id
self.deposit_claim.payer_deposit_account = self.deposit_account
self.deposit_claim.payee_ethereum_address = self.task_to_compute.provider_ethereum_address
self.deposit_claim.concent_use_case = ConcentUseCase.FORCED_ACCEPTANCE
self.deposit_claim.amount = 2
self.deposit_claim.clean()
self.deposit_claim.save()
def test_that_exception_is_raised_when_ethereum_address_has_wrong_type(self):
with pytest.raises(ValidationError) as exception_info:
deposit_account = DepositAccount(
client=self.client,
ethereum_address=b'x' * ETHEREUM_ADDRESS_LENGTH
)
deposit_account.clean()
self.assertIn('ethereum_address', exception_info.value.error_dict)
def test_that_exception_is_raised_when_ethereum_address_has_wrong_length(self):
with pytest.raises(ValidationError) as exception_info:
deposit_account = DepositAccount(
client=self.client,
ethereum_address=self.payer_ethereum_address + '1'
)
deposit_account.clean()
self.assertIn('ethereum_address', exception_info.value.error_dict)
def create_client_and_related_deposit_account(self):
self.requestor_client = Client(
public_key=self.task_to_compute.requestor_id)
self.requestor_client.full_clean()
self.requestor_client.save()
self.requestor_deposit_account = DepositAccount(
client=self.requestor_client,
ethereum_address=self.task_to_compute.requestor_ethereum_address,
)
self.requestor_deposit_account.full_clean()
self.requestor_deposit_account.save()
class DiscardClaimBanksterTest(ConcentIntegrationTestCase):
def setUp(self):
super().setUp()
self.task_to_compute = self._get_deserialized_task_to_compute()
self.client = Client(public_key_bytes=self.PROVIDER_PUBLIC_KEY)
self.client.clean()
self.client.save()
self.deposit_account = DepositAccount()
self.deposit_account.client = self.client
self.deposit_account.ethereum_address = self.task_to_compute.requestor_ethereum_address
self.deposit_account.clean()
self.deposit_account.save()
self.deposit_claim = DepositClaim()
self.deposit_claim.payer_deposit_account = self.deposit_account
self.deposit_claim.payee_ethereum_address = self.task_to_compute.provider_ethereum_address
self.deposit_claim.concent_use_case = ConcentUseCase.FORCED_PAYMENT
self.deposit_claim.amount = 1
self.deposit_claim.closure_time = parse_timestamp_to_utc_datetime(
get_current_utc_timestamp())
self.deposit_claim.full_clean()
self.deposit_claim.save()
def test_that_discard_claim_should_return_false_and_not_remove_deposit_claim_if_tx_hash_is_none(
self):
claim_removed = discard_claim(self.deposit_claim)
self.assertFalse(claim_removed)
self.assertTrue(
DepositClaim.objects.filter(pk=self.deposit_claim.pk).exists())
def test_that_discard_claim_should_return_true_and_remove_deposit_claim_if_tx_hash_is_set(
self):
self.deposit_claim.tx_hash = 64 * '0'
self.deposit_claim.clean()
self.deposit_claim.save()
claim_removed = discard_claim(self.deposit_claim)
self.assertTrue(claim_removed)
self.assertFalse(
DepositClaim.objects.filter(pk=self.deposit_claim.pk).exists())
def setUp(self):
super().setUp()
self.task_to_compute = self._get_deserialized_task_to_compute()
self.client = Client(public_key_bytes=self.PROVIDER_PUBLIC_KEY)
self.client.clean()
self.client.save()
self.deposit_account = DepositAccount()
self.deposit_account.client = self.client
self.deposit_account.ethereum_address = self.task_to_compute.requestor_ethereum_address
self.deposit_account.clean()
self.deposit_account.save()
self.deposit_claim = DepositClaim()
self.deposit_claim.payer_deposit_account = self.deposit_account
self.deposit_claim.payee_ethereum_address = self.task_to_compute.provider_ethereum_address
self.deposit_claim.concent_use_case = ConcentUseCase.FORCED_PAYMENT
self.deposit_claim.amount = 1
self.deposit_claim.clean()
self.deposit_claim.save()
def test_that_exception_is_not_raised_when_ethereum_address_has_valid_length(self):
deposit_account = DepositAccount(
client=self.client,
ethereum_address=self.payer_ethereum_address
)
deposit_account.clean()
deposit_account.save()
def setUp(self):
super().setUp()
task_to_compute = self._get_deserialized_task_to_compute()
self.payer_ethereum_address = task_to_compute.requestor_ethereum_address
self.payee_ethereum_address = task_to_compute.provider_ethereum_address
client = Client(public_key_bytes=self.REQUESTOR_PUBLIC_KEY)
client.clean()
client.save()
self.payer_deposit_account = DepositAccount()
self.payer_deposit_account.client = client
self.payer_deposit_account.ethereum_address = task_to_compute.requestor_ethereum_address
self.payer_deposit_account.clean()
self.payer_deposit_account.save()
self.deposit_claim = DepositClaim()
self.deposit_claim.payer_deposit_account = self.payer_deposit_account
self.deposit_claim.subtask_id = task_to_compute.subtask_id
self.deposit_claim.payee_ethereum_address = self.payee_ethereum_address
self.deposit_claim.concent_use_case = ConcentUseCase.FORCED_TASK_RESULT.value
self.deposit_claim.amount = 1
self.deposit_claim.tx_hash = encode_hex(MOCK_TRANSACTION.hash)
class SettleOverdueAcceptancesBanksterTest(ConcentIntegrationTestCase):
def setUp(self):
super().setUp()
self.get_deposit_value_return_value_default = 15000
self.task_to_compute = None
self.subtask_results_accepted_list = None
self.requestor_client = None
self.requestor_deposit_account = None
self.validate_list_of_transaction_mock = None
self.get_deposit_value_mock = None
self.get_list_of_payments_mock = None
def create_subtask_results_accepted_list(self, price, number_of_items=1):
self.task_to_compute = self._get_deserialized_task_to_compute(
price=price)
self.subtask_results_accepted_list = [
self._get_deserialized_subtask_results_accepted(
report_computed_task=self.
_get_deserialized_report_computed_task(
timestamp="2018-02-04 10:00:05",
task_to_compute=self.task_to_compute))
for _ in range(number_of_items)
]
def create_client_and_related_deposit_account(self):
self.requestor_client = Client(
public_key=self.task_to_compute.requestor_id)
self.requestor_client.full_clean()
self.requestor_client.save()
self.requestor_deposit_account = DepositAccount(
client=self.requestor_client,
ethereum_address=self.task_to_compute.requestor_ethereum_address,
)
self.requestor_deposit_account.full_clean()
self.requestor_deposit_account.save()
def create_deposit_claim(self, amount, tx_hash):
deposit_claim = DepositClaim(
payee_ethereum_address=self.task_to_compute.
provider_ethereum_address,
payer_deposit_account=self.requestor_deposit_account,
amount=amount,
concent_use_case=ConcentUseCase.FORCED_PAYMENT,
tx_hash=tx_hash,
closure_time=parse_timestamp_to_utc_datetime(
get_current_utc_timestamp()),
)
deposit_claim.full_clean()
deposit_claim.save()
def call_settle_overdue_acceptances_with_mocked_sci_functions(
self,
get_deposit_value_return_value=None,
get_list_of_payments_return_value=None,
):
with freeze_time("2018-02-05 10:00:25"):
with mock.patch(
'core.payments.bankster.validate_list_of_transaction_timestamp'
) as self.validate_list_of_transaction_mock:
with mock.patch(
'core.payments.bankster.service.get_deposit_value',
return_value=(
get_deposit_value_return_value
if get_deposit_value_return_value is not None else
self.get_deposit_value_return_value_default),
) as self.get_deposit_value_mock:
with mock.patch(
'core.payments.bankster.service.get_list_of_payments',
side_effect=[
(get_list_of_payments_return_value
if get_list_of_payments_return_value
is not None else
self._get_list_of_settlement_transactions()),
self._get_list_of_batch_transactions()
],
) as self.get_list_of_payments_mock:
claim_against_requestor = settle_overdue_acceptances(
requestor_ethereum_address=self.task_to_compute.
requestor_ethereum_address,
provider_ethereum_address=self.task_to_compute.
provider_ethereum_address,
acceptances=self.subtask_results_accepted_list,
requestor_public_key=hex_to_bytes_convert(
self.task_to_compute.requestor_public_key),
)
return claim_against_requestor
def assert_mocked_sci_functions_were_called(
self, get_list_of_payments_call_count=2):
self.get_deposit_value_mock.assert_called_once()
self.validate_list_of_transaction_mock.assert_called_once()
self.assertEqual(self.get_list_of_payments_mock.call_count,
get_list_of_payments_call_count)
def test_that_settle_overdue_acceptances_should_raise_no_unsettled_tasks_exception_when_all_tasks_are_paid_off(
self):
"""
In this test we have following calculations:
TaskToCompute price: 3000
Sum of amounts from list of settlement transactions: 3000
Sum of amounts from list of transactions: 4000 (does not matter in this case)
Requestor deposit value: 15000 (does not matter in this case)
Amount pending = 3000 - 3000 = 0
"""
self.create_subtask_results_accepted_list(price=3000)
with self.assertRaises(BanksterNoUnsettledTasksError):
self.call_settle_overdue_acceptances_with_mocked_sci_functions()
self.assert_mocked_sci_functions_were_called()
def test_that_settle_overdue_acceptances_should_raise_too_small_requestor_deposit_exception_when_requestor_has_insufficient_funds(
self):
"""
In this test we have following calculations
(functions are mocked, but values are set to better understand calculations):
TaskToCompute price: 12000
Sum of amounts from list of settlement transactions: 3000
Sum of amounts from list of transactions: 4000
Requestor deposit value: 0
"""
subtasks_collective_price = 12000
already_paid_in_transactions = 3000 + 4000
self.create_subtask_results_accepted_list(
price=subtasks_collective_price)
with mock.patch(
'core.payments.bankster.find_unconfirmed_settlement_payments'):
with mock.patch('core.payments.bankster.get_provider_payment_info',
return_value=(already_paid_in_transactions,
subtasks_collective_price -
already_paid_in_transactions)):
with self.assertRaises(BanksterTooSmallRequestorDepositError):
self.call_settle_overdue_acceptances_with_mocked_sci_functions(
get_deposit_value_return_value=0, )
self.assert_mocked_sci_functions_were_called()
def test_that_settle_overdue_acceptances_should_return_claim_deposit_with_amount_paid(
self):
"""
In this test we have following calculations:
TaskToCompute price: 15000
Sum of amounts from list of settlement transactions: 3000
Sum of amounts from list of transactions: 4000
Requestor deposit value: 15000
Amount pending = 15000 - (3000 + 4000) = 8000
Payable amount = min(15000, 8000) = 8000
"""
self.create_subtask_results_accepted_list(price=15000)
claim_against_requestor = self.call_settle_overdue_acceptances_with_mocked_sci_functions(
)
self.assertIsNotNone(claim_against_requestor.tx_hash)
self.assertEqual(claim_against_requestor.amount, 8000)
self.assert_mocked_sci_functions_were_called()
def test_that_settle_overdue_acceptances_should_return_claim_deposit_with_amount_paid_if_there_was_no_previous_settlement_transactions(
self):
"""
In this test we have following calculations:
TaskToCompute price: 15000
Sum of amounts from list of settlement transactions: 0
Sum of amounts from list of transactions: 4000
Requestor deposit value: 20000
Amount pending = 15000 - 4000 = 11000
Payable amount = min(11000, 20000) = 11000
"""
self.create_subtask_results_accepted_list(price=15000)
claim_against_requestor = self.call_settle_overdue_acceptances_with_mocked_sci_functions(
get_deposit_value_return_value=20000,
get_list_of_payments_return_value=[],
)
self.assertIsNotNone(claim_against_requestor.tx_hash)
self.assertEqual(claim_against_requestor.amount, 11000)
self.assert_mocked_sci_functions_were_called()
def test_that_settle_overdue_acceptances_should_return_claim_deposit_with_amount_paid_when_requesting_payment_for_multiple_subtasks(
self):
"""
In this test we have following calculations:
TaskToCompute price: 2 x 7500 = 15000
Sum of amounts from list of settlement transactions: 3000
Sum of amounts from list of transactions: 4000
Requestor deposit value: 15000
Amount pending = 15000 - (3000 + 4000) = 8000
Payable amount = min(8000, 15000) = 8000
"""
self.create_subtask_results_accepted_list(price=7500,
number_of_items=2)
claim_against_requestor = self.call_settle_overdue_acceptances_with_mocked_sci_functions(
)
self.assertIsNotNone(claim_against_requestor.tx_hash)
self.assertEqual(claim_against_requestor.amount, 8000)
self.assert_mocked_sci_functions_were_called()
def test_that_settle_overdue_acceptances_should_return_claim_deposit_with_amount_available_on_requestor_deposit_if_it_is_greater_then_left_amount(
self):
"""
In this test we have following calculations:
TaskToCompute price: 15000
Sum of amounts from list of settlement transactions: 3000
Sum of amounts from list of transactions: 4000
Requestor deposit value: 5000
Amount pending = 15000 - (3000 + 4000) = 8000
Payable amount = min(8000, 5000) = 5000
"""
self.create_subtask_results_accepted_list(price=15000)
claim_against_requestor = self.call_settle_overdue_acceptances_with_mocked_sci_functions(
get_deposit_value_return_value=5000, )
self.assertIsNotNone(claim_against_requestor.tx_hash)
self.assertEqual(claim_against_requestor.amount, 5000)
self.assert_mocked_sci_functions_were_called()
def test_that_settle_overdue_acceptances_should_return_claim_deposit_with_amount_paid_when_there_are_existing_claims(
self):
"""
In this test we have following calculations:
TaskToCompute price: 15000
Sum of amounts from list of settlement transactions: 0
Sum of amounts from list of transactions: 4000
Requestor deposit value: 15000
Sum of existing claims: 7000
Amount pending = 15000 - (4000 + 7000) = 4000
Payable amount = min(4000, 15000) = 4000
"""
self.create_subtask_results_accepted_list(price=15000)
self.create_client_and_related_deposit_account()
self.create_deposit_claim(
amount=3000,
tx_hash=64 * 'A',
)
self.create_deposit_claim(
amount=4000,
tx_hash=64 * 'B',
)
claim_against_requestor = self.call_settle_overdue_acceptances_with_mocked_sci_functions(
get_list_of_payments_return_value=[])
self.assertIsNotNone(claim_against_requestor.tx_hash)
self.assertEqual(claim_against_requestor.amount, 4000)
self.assert_mocked_sci_functions_were_called()
def test_that_settle_overdue_acceptances_should_return_claim_deposit_with_amount_paid_when_there_are_both_existing_claims_and_payments(
self):
"""
In this test we have following calculations:
TaskToCompute price: 15000
Sum of amounts from list of settlement transactions: 3000
Sum of amounts from list of transactions: 4000
Requestor deposit value: 15000
Sum of existing claims: 7000
Amount pending = 15000 - (3000 + 4000 + 7000) = 1000
Payable amount = min(1000, 15000) = 1000
"""
self.create_subtask_results_accepted_list(price=15000)
self.create_client_and_related_deposit_account()
self.create_deposit_claim(
amount=3000,
tx_hash=64 * 'A',
)
self.create_deposit_claim(
amount=4000,
tx_hash=64 * 'B',
)
claim_against_requestor = self.call_settle_overdue_acceptances_with_mocked_sci_functions(
)
self.assertIsNotNone(claim_against_requestor.tx_hash)
self.assertEqual(claim_against_requestor.amount, 1000)
self.assert_mocked_sci_functions_were_called()
def test_that_settle_overdue_acceptances_should_return_claim_deposit_with_amount_paid_when_there_are_both_existing_claims_and_payments_with_the_same_transaction_hash(
self):
"""
In this test we have following calculations:
TaskToCompute price: 15000
Sum of amounts from list of settlement transactions: 2000
Sum of amounts from list of transactions: 4000
Requestor deposit value: 15000
Sum of existing claims: 6000
Amount pending = 15000 - (2000 + 4000 + 6000 - 2000) = 5000 // (2000 from claim matching blockchain transaction is ignored)
Payable amount = min(5000, 15000) = 5000
"""
self.create_subtask_results_accepted_list(price=15000)
self.create_client_and_related_deposit_account()
with freeze_time("2018-02-05 10:00:25"):
self.create_deposit_claim(
amount=2000,
tx_hash=MOCK_TRANSACTION_HASH,
)
self.create_deposit_claim(
amount=4000,
tx_hash=64 * 'B',
)
with freeze_time("2018-02-05 10:00:25"):
list_of_payments_return_value = [
self._create_settlement_payment_object(amount=2000, )
]
claim_against_requestor = self.call_settle_overdue_acceptances_with_mocked_sci_functions(
get_list_of_payments_return_value=list_of_payments_return_value, )
self.assertIsNotNone(claim_against_requestor.tx_hash)
self.assertEqual(claim_against_requestor.amount, 5000)
self.assert_mocked_sci_functions_were_called()
def test_that_settle_overdue_acceptances_should_raise_exception_if_transaction_from_blockchain_will_not_match_database_claim(
self):
"""
In this test we have following calculations:
TaskToCompute price: 15000
Sum of amounts from list of settlement transactions: 3000
Sum of amounts from list of transactions: 4000
Requestor deposit value: 15000
Sum of existing claims: 7000
"""
self.create_subtask_results_accepted_list(price=15000)
self.create_client_and_related_deposit_account()
self.create_deposit_claim(
amount=3000,
tx_hash=MOCK_TRANSACTION_HASH,
)
with self.assertRaises(BanksterTransactionMismatchError):
self.call_settle_overdue_acceptances_with_mocked_sci_functions()
self.assert_mocked_sci_functions_were_called(
get_list_of_payments_call_count=1)
class FinalizePaymentBanksterTest(ConcentIntegrationTestCase):
def setUp(self):
super().setUp()
self.task_to_compute = self._get_deserialized_task_to_compute()
self.subtask = store_subtask(
task_id=self.task_to_compute.task_id,
subtask_id=self.task_to_compute.subtask_id,
provider_public_key=self.PROVIDER_PUBLIC_KEY,
requestor_public_key=self.REQUESTOR_PUBLIC_KEY,
state=Subtask.SubtaskState.ACCEPTED,
next_deadline=None,
task_to_compute=self.task_to_compute,
report_computed_task=factories.tasks.ReportComputedTaskFactory(
task_to_compute=self.task_to_compute))
self.subtask.full_clean()
self.subtask.save()
self.deposit_account = DepositAccount()
self.deposit_account.client = self.subtask.requestor
self.deposit_account.ethereum_address = self.task_to_compute.requestor_ethereum_address
self.deposit_account.clean()
self.deposit_account.save()
self.deposit_claim = DepositClaim()
self.deposit_claim.subtask_id = self.task_to_compute.subtask_id
self.deposit_claim.payer_deposit_account = self.deposit_account
self.deposit_claim.payee_ethereum_address = self.task_to_compute.provider_ethereum_address
self.deposit_claim.concent_use_case = ConcentUseCase.FORCED_ACCEPTANCE
self.deposit_claim.amount = 2
self.deposit_claim.clean()
self.deposit_claim.save()
def test_that_when_available_funds_are_zero_finalize_payment_should_delete_deposit_claim_and_return_none(
self):
with mock.patch('core.payments.service.get_deposit_value',
return_value=0) as get_deposit_value:
returned_value = finalize_payment(self.deposit_claim)
self.assertIsNone(returned_value)
self.assertFalse(
DepositClaim.objects.filter(pk=self.deposit_claim.pk).exists())
get_deposit_value.assert_called_with(
client_eth_address=self.deposit_claim.payer_deposit_account.
ethereum_address, )
def test_that_when_deposit_claim_is_for_forced_acceptance_use_case_finalize_payment_should_call_force_subtask_payment(
self):
(v, r, s) = self.task_to_compute.promissory_note_sig
with mock.patch('core.payments.service.get_deposit_value',
return_value=2) as get_deposit_value:
with mock.patch('core.payments.service.force_subtask_payment',
return_value=MOCK_TRANSACTION_HASH
) as force_subtask_payment:
returned_value = finalize_payment(self.deposit_claim)
self.assertEqual(returned_value, MOCK_TRANSACTION_HASH)
get_deposit_value.assert_called_with(
client_eth_address=self.deposit_claim.payer_deposit_account.
ethereum_address, )
force_subtask_payment.assert_called_once_with(
requestor_eth_address=self.deposit_claim.payer_deposit_account.
ethereum_address,
provider_eth_address=self.deposit_claim.payee_ethereum_address,
value=self.task_to_compute.price,
subtask_id=self.deposit_claim.subtask_id,
v=v,
r=r,
s=s,
reimburse_amount=self.deposit_claim.amount)
def test_that_when_deposit_claim_is_for_additional_verification_use_case_finalize_payment_should_call_cover_additional_verification_cost(
self):
self.deposit_claim.concent_use_case = ConcentUseCase.ADDITIONAL_VERIFICATION
self.deposit_claim.clean()
self.deposit_claim.save()
(v, r, s) = self.task_to_compute.promissory_note_sig
with mock.patch('core.payments.service.get_deposit_value',
return_value=2) as get_deposit_value:
with mock.patch('core.payments.service.force_subtask_payment',
return_value=MOCK_TRANSACTION_HASH
) as force_subtask_payment:
returned_value = finalize_payment(self.deposit_claim)
self.assertEqual(returned_value, MOCK_TRANSACTION_HASH)
get_deposit_value.assert_called_with(
client_eth_address=self.deposit_claim.payer_deposit_account.
ethereum_address, )
force_subtask_payment.assert_called_once_with(
requestor_eth_address=self.deposit_claim.payer_deposit_account.
ethereum_address,
provider_eth_address=self.deposit_claim.payee_ethereum_address,
value=self.task_to_compute.price,
subtask_id=self.deposit_claim.subtask_id,
v=v,
r=r,
s=s,
reimburse_amount=self.deposit_claim.amount)
def test_that_when_there_are_other_deposit_claims_finalize_payment_substract_them_from_currently_processed_claim(
self):
newest_deposit_claim, newest_task_to_compute = self.create_n_deposits_with_subtasks(
2)
(v, r, s) = newest_task_to_compute.promissory_note_sig
with mock.patch('core.payments.service.get_deposit_value',
return_value=5) as get_deposit_value:
with mock.patch('core.payments.service.force_subtask_payment',
return_value=MOCK_TRANSACTION_HASH
) as force_subtask_payment:
returned_value = finalize_payment(newest_deposit_claim)
self.assertEqual(returned_value, MOCK_TRANSACTION_HASH)
get_deposit_value.assert_called_with(
client_eth_address=newest_deposit_claim.payer_deposit_account.
ethereum_address, )
force_subtask_payment.assert_called_once_with(
requestor_eth_address=newest_deposit_claim.payer_deposit_account.
ethereum_address,
provider_eth_address=newest_deposit_claim.payee_ethereum_address,
value=newest_task_to_compute.price,
subtask_id=newest_deposit_claim.subtask_id,
v=v,
r=r,
s=s,
# 5 - (2 + 2) | deposit_value - sum_of_other_claims
reimburse_amount=1,
)
def create_n_deposits_with_subtasks(self, n=1, amount=2):
for _ in range(n):
task_to_compute = self._get_deserialized_task_to_compute(
provider_public_key=self._get_provider_hex_public_key(),
requestor_public_key=self._get_requestor_hex_public_key(),
price=amount,
)
store_subtask(
task_id=task_to_compute.task_id,
subtask_id=task_to_compute.subtask_id,
provider_public_key=self.PROVIDER_PUBLIC_KEY,
requestor_public_key=self.REQUESTOR_PUBLIC_KEY,
state=Subtask.SubtaskState.ACCEPTED,
next_deadline=None,
task_to_compute=task_to_compute,
report_computed_task=factories.tasks.ReportComputedTaskFactory(
task_to_compute=task_to_compute))
deposit_claim = DepositClaim()
deposit_claim.subtask_id = task_to_compute.subtask_id
deposit_claim.payer_deposit_account = self.deposit_account
deposit_claim.payee_ethereum_address = task_to_compute.provider_ethereum_address
deposit_claim.concent_use_case = ConcentUseCase.FORCED_ACCEPTANCE
deposit_claim.amount = amount
deposit_claim.clean()
deposit_claim.save()
return deposit_claim, task_to_compute
class TestDepositClaimValidation(ConcentIntegrationTestCase):
def setUp(self):
super().setUp()
task_to_compute = self._get_deserialized_task_to_compute()
self.payer_ethereum_address = task_to_compute.requestor_ethereum_address
self.payee_ethereum_address = task_to_compute.provider_ethereum_address
client = Client(public_key_bytes=self.REQUESTOR_PUBLIC_KEY)
client.clean()
client.save()
self.payer_deposit_account = DepositAccount()
self.payer_deposit_account.client = client
self.payer_deposit_account.ethereum_address = task_to_compute.requestor_ethereum_address
self.payer_deposit_account.clean()
self.payer_deposit_account.save()
self.deposit_claim = DepositClaim()
self.deposit_claim.payer_deposit_account = self.payer_deposit_account
self.deposit_claim.subtask_id = task_to_compute.subtask_id
self.deposit_claim.payee_ethereum_address = self.payee_ethereum_address
self.deposit_claim.concent_use_case = ConcentUseCase.FORCED_TASK_RESULT.value
self.deposit_claim.amount = 1
self.deposit_claim.tx_hash = encode_hex(MOCK_TRANSACTION.hash)
def test_that_exception_is_raised_when_subtask_is_null_and_concent_use_case_is_not_forced_payment(self):
self.deposit_claim.subtask_id = None
with pytest.raises(ValidationError) as exception_info:
self.deposit_claim.clean()
self.assertIn('subtask_id', exception_info.value.error_dict)
def test_that_exception_is_not_raised_when_subtask_is_null_and_concent_use_case_is_forced_payment(self):
self.deposit_claim.subtask = None
self.deposit_claim.concent_use_case = ConcentUseCase.FORCED_PAYMENT.value
self.deposit_claim.clean()
def test_that_exception_is_raised_when_payee_ethereum_address_is_the_same_as_payer_deposit_account_ethereum_address(self):
self.deposit_claim.payee_ethereum_address = self.deposit_claim.payer_deposit_account.ethereum_address
with pytest.raises(ValidationError) as exception_info:
self.deposit_claim.clean()
self.assertIn('payer_deposit_account', exception_info.value.error_dict)
def test_that_exception_is_raised_when_payee_ethereum_address_has_wrong_length(self):
self.deposit_claim.payee_ethereum_address = self.payee_ethereum_address + '1'
with pytest.raises(ValidationError) as exception_info:
self.deposit_claim.clean()
self.assertIn('payee_ethereum_address', exception_info.value.error_dict)
def test_that_exception_is_raised_when_payee_ethereum_address_has_wrong_type(self):
self.deposit_claim.payee_ethereum_address = b'x' * ETHEREUM_ADDRESS_LENGTH
with pytest.raises(ValidationError) as exception_info:
self.deposit_claim.clean()
self.assertIn('payee_ethereum_address', exception_info.value.error_dict)
def test_that_exception_is_raised_when_amount_is_equal_to_zero(self):
self.deposit_claim.amount = 0
with pytest.raises(ValidationError) as exception_info:
self.deposit_claim.clean()
self.assertIn('amount', exception_info.value.error_dict)
def test_that_exception_is_raised_when_amount_is_less_then_zero(self):
self.deposit_claim.amount = -1
with pytest.raises(ValidationError) as exception_info:
self.deposit_claim.clean()
self.assertIn('amount', exception_info.value.error_dict)
def test_that_exception_is_raised_when_amount_is_of_wrong_type(self):
self.deposit_claim.amount = 5.0
with pytest.raises(ValidationError):
self.deposit_claim.clean()
def test_that_exception_is_raised_when_tx_hash_is_not_none_and_not_string(self):
self.deposit_claim.tx_hash = b'x' * ETHEREUM_TRANSACTION_HASH_LENGTH
with pytest.raises(ValidationError) as exception_info:
self.deposit_claim.clean()
self.assertIn('tx_hash', exception_info.value.error_dict)
def test_that_exception_is_raised_when_tx_hash_has_wrong_length(self):
self.deposit_claim.tx_hash = encode_hex(MOCK_TRANSACTION.hash) + 'a'
with pytest.raises(ValidationError) as exception_info:
self.deposit_claim.clean()
self.assertIn('tx_hash', exception_info.value.error_dict)
def test_that_no_exception_is_raised_when_tx_hash_is_none(self):
self.deposit_claim.tx_hash = None
self.deposit_claim.clean()
self.deposit_claim.save()
def test_that_deposit_account_is_not_removed_when_deposit_claim_is_deleted(self):
self.deposit_claim.clean()
self.deposit_claim.save()
DepositClaim.objects.filter(pk=self.deposit_claim.pk).delete()
self.assertTrue(
DepositAccount.objects.filter(pk=self.payer_deposit_account.pk).exists() # pylint: disable=no-member
)
def test_that_no_exception_is_raised_when_deposit_claim_is_valid(self):
self.deposit_claim.clean()
self.deposit_claim.save()
class TestDepositClaimValidation(ConcentIntegrationTestCase):
def setUp(self):
super().setUp()
task_to_compute = self._get_deserialized_task_to_compute()
self.payer_ethereum_address = task_to_compute.requestor_ethereum_address
self.payee_ethereum_address = task_to_compute.provider_ethereum_address
client = Client(public_key_bytes=self.REQUESTOR_PUBLIC_KEY)
client.clean()
client.save()
self.payer_deposit_account = DepositAccount()
self.payer_deposit_account.client = client
self.payer_deposit_account.ethereum_address = task_to_compute.requestor_ethereum_address
self.payer_deposit_account.clean()
self.payer_deposit_account.save()
self.deposit_claim = DepositClaim()
self.deposit_claim.payer_deposit_account = self.payer_deposit_account
self.deposit_claim.subtask_id = task_to_compute.subtask_id
self.deposit_claim.payee_ethereum_address = self.payee_ethereum_address
self.deposit_claim.concent_use_case = ConcentUseCase.FORCED_TASK_RESULT.value
self.deposit_claim.amount = 1
self.deposit_claim.tx_hash = encode_hex(MOCK_TRANSACTION.hash)
def test_that_exception_is_raised_when_subtask_is_null_and_concent_use_case_is_not_forced_payment(
self):
self.deposit_claim.subtask_id = None
with pytest.raises(ValidationError) as exception_info:
self.deposit_claim.clean()
self.assertIn('subtask_id', exception_info.value.error_dict)
def test_that_exception_is_not_raised_when_subtask_is_null_and_concent_use_case_is_forced_payment(
self):
self.deposit_claim.subtask = None
self.deposit_claim.concent_use_case = ConcentUseCase.FORCED_PAYMENT.value
self.deposit_claim.closure_time = parse_timestamp_to_utc_datetime(
get_current_utc_timestamp())
self.deposit_claim.clean()
def test_that_exception_is_raised_when_payee_ethereum_address_is_the_same_as_payer_deposit_account_ethereum_address(
self):
self.deposit_claim.payee_ethereum_address = self.deposit_claim.payer_deposit_account.ethereum_address
with pytest.raises(ValidationError) as exception_info:
self.deposit_claim.clean()
self.assertIn('payer_deposit_account', exception_info.value.error_dict)
def test_that_exception_is_raised_when_amount_is_equal_to_zero(self):
self.deposit_claim.amount = 0
with pytest.raises(ValidationError) as exception_info:
self.deposit_claim.clean()
self.assertIn('amount', exception_info.value.error_dict)
def test_that_exception_is_raised_when_amount_is_less_then_zero(self):
self.deposit_claim.amount = -1
with pytest.raises(ValidationError) as exception_info:
self.deposit_claim.clean()
self.assertIn('amount', exception_info.value.error_dict)
def test_that_exception_is_not_raised_when_amount_is_at_max_length(self):
self.deposit_claim.amount = int('1' * BIG_ENDIAN_INT_MAX_DIGITS)
self.deposit_claim.clean()
self.deposit_claim.save()
def test_that_exception_is_raised_when_tx_hash_is_not_none_and_not_string(
self):
self.deposit_claim.tx_hash = '11'
self.deposit_claim.clean()
self.deposit_claim.save()
def test_that_exception_is_raised_when_closure_time_is_none_in_use_case_forced_payment(
self):
self.deposit_claim.concent_use_case = ConcentUseCase.FORCED_PAYMENT.value
self.deposit_claim.closure_time = None
with pytest.raises(ValidationError) as exception_info:
self.deposit_claim.clean()
self.assertIn('closure_time', exception_info.value.error_dict)
def test_that_exception_is_raised_when_closure_time_is_set_in_use_case_other_than_forced_payment(
self):
self.deposit_claim.concent_use_case = ConcentUseCase.ADDITIONAL_VERIFICATION.value
self.deposit_claim.closure_time = parse_timestamp_to_utc_datetime(
get_current_utc_timestamp())
with pytest.raises(ValidationError) as exception_info:
self.deposit_claim.clean()
self.assertIn('closure_time', exception_info.value.error_dict)
def test_that_no_exception_is_raised_when_tx_hash_is_none(self):
self.deposit_claim.tx_hash = None
self.deposit_claim.clean()
self.deposit_claim.save()
def test_that_deposit_account_is_not_removed_when_deposit_claim_is_deleted(
self):
self.deposit_claim.clean()
self.deposit_claim.save()
DepositClaim.objects.filter(pk=self.deposit_claim.pk).delete()
self.assertTrue(
DepositAccount.objects.filter(
pk=self.payer_deposit_account.pk).exists() # pylint: disable=no-member
)
def test_that_no_exception_is_raised_when_deposit_claim_is_valid(self):
self.deposit_claim.clean()
self.deposit_claim.save()