def test_committed_unknown(self, _log_mock):
fpc = msg_factories.concents.ForcePaymentCommittedFactory(
amount_pending=31337,
recipient_type=None,
)
with self.assertRaises(ValueError):
library.interpret(fpc)
def test_force_get_task_result_download(self):
fgtrd = self._get_correct_message()
library.interpret(fgtrd)
ep = ExtractedPackageFactory()
extract = \
self.task_server.task_manager.task_result_manager.extract_zip = \
mock.Mock(return_value=ep)
verify_results = self.task_server.verify_results = mock.Mock()
with mock.patch(
'golem.network.concent.filetransfers'
'.ConcentFiletransferService.download', ) as download_mock:
self.cft._run()
download_mock.assert_called_once()
self.assertEqual(download_mock.call_args[0][0].file_transfer_token,
fgtrd.file_transfer_token)
extract.assert_called_once()
verify_results.assert_called_once_with(report_computed_task=self.rct,
extracted_package=ep)
def test_committed_provider(self, log_mock):
fpc = msg_factories.concents.ForcePaymentCommittedFactory.to_provider(
amount_pending=31337, )
library.interpret(fpc)
self.assertIn(
"Forced payment from",
log_mock.call_args[0][0],
)
def test_force_subtask_results_response_empty(self):
msg = message.concents.ForceSubtaskResultsResponse()
# pylint: disable=no-member
self.assertIsNone(msg.subtask_results_accepted)
self.assertIsNone(msg.subtask_results_rejected)
# pylint: enable=no-member
with self.assertRaises(RuntimeError):
library.interpret(msg)
def test_fgtr_service_refused(self, tcf):
fgtr = msg_factories.concents.ForceGetTaskResultFactory()
sr = msg_factories.concents.ServiceRefusedFactory(
task_to_compute__subtask_id=fgtr.subtask_id)
library.interpret(sr, response_to=fgtr)
tcf.assert_called_once_with(
fgtr.subtask_id,
'Concent refused to assist in forced results download')
def test_committed_requestor(self, log_mock):
fpc = msg_factories.concents.ForcePaymentCommittedFactory.to_requestor(
)
library.interpret(fpc)
log_mock.assert_called_once()
self.assertIn(
"Our deposit was used to cover payment",
log_mock.call_args[0][0],
)
def test_ack_subtask_results_verify_no_resources(self, upload_mock,
log_mock):
self.task_server.results_to_send[self.wtr.subtask_id] = self.wtr
asrv = self.get_asrv()
library.interpret(asrv)
self.cft._run()
self.cft._run()
self.assertEqual(upload_mock.call_count, 1)
self.assertIn('Cannot upload resources', log_mock.call_args[0][0])
def test_settled(self):
srs = msg_factories.concents.SubtaskResultsSettledFactory()
self.task_server.client.node.key = srs.task_to_compute.provider_id
library.interpret(srs)
self.client.transaction_system.settle_income.assert_called_once_with(
srs.task_to_compute.requestor_id,
srs.subtask_id,
srs.timestamp,
)
def test_positive_path(self, last_resort_mock, get_mock):
get_mock.return_value = msg_factories \
.tasks \
.SubtaskResultsAcceptedFactory()
library.interpret(self.msg)
last_resort_mock.assert_not_called()
self.task_server.client.concent_service.submit_task_message \
.assert_called_once_with(
get_mock().subtask_id,
mock.ANY)
def test_ack_subtask_results_verify_no_results(self, upload_mock,
log_mock):
self.task_server.task_manager.comp_task_keeper.add_package_paths(
self.wtr.task_id, [self.path])
asrv = self.get_asrv()
library.interpret(asrv)
self.cft._run()
self.cft._run()
self.assertEqual(upload_mock.call_count, 1)
self.assertIn('Cannot find the subtask', log_mock.call_args[0][0])
def test_subtask_timeout(self, add_mock):
self.msg.ack_report_computed_task = None
self.msg.reject_report_computed_task = None
self.msg.reason = self.reasons.SubtaskTimeout
library.interpret(self.msg)
add_mock.assert_called_once_with(
msg=self.msg,
node_id=None,
local_role=Actor.Provider,
remote_role=Actor.Concent,
)
def test_verdict_report_computed_task_diff_ttc(self, verify_mock):
msg = msg_factories.concents.VerdictReportComputedTaskFactory()
msg.ack_report_computed_task.report_computed_task.task_to_compute = \
msg_factories.tasks.TaskToComputeFactory()
self.assertNotEqual(
msg.ack_report_computed_task.task_to_compute,
msg.force_report_computed_task.report_computed_task.
task_to_compute,
)
library.interpret(msg)
verify_mock.assert_not_called()
def test_force_subtask_results_response_rejected(self, rejected_mock,
add_mock):
msg = msg_factories.concents.\
ForceSubtaskResultsResponseFactory.with_rejected()
library.interpret(msg)
rejected_mock.assert_called_once_with(subtask_id=msg.subtask_id, )
add_mock.assert_called_once_with(
msg=msg.subtask_results_rejected,
node_id=mock.ANY,
local_role=Actor.Provider,
remote_role=Actor.Requestor,
)
def process_messages_received_from_concent(concent_service):
# Process first 50 messages only in one sync
for _ in range(50):
try:
msg = concent_service.received_messages.get_nowait()
except queue.Empty:
break
try:
library.interpret(msg)
except Exception: # pylint: disable=broad-except
logger.exception('Problem interpreting: %r', msg)
concent_service.received_messages.task_done()
def test_force_report_computed_task(self, pull_mock, _mdt_mock,
helper_mock):
msg = msg_factories.concents.ForceReportComputedTaskFactory()
helper_mock.return_value = returned_msg = object()
library.interpret(msg)
helper_mock.assert_called_once_with(
msg=msg.report_computed_task,
ecc=mock.ANY,
)
self.task_server.client.concent_service.submit_task_message \
.assert_any_call(
msg.report_computed_task.subtask_id,
returned_msg)
pull_mock.assert_called()
def test_reject_from_requestor(self, add_mock):
self.msg.reason = self.reasons.RejectFromRequestor
library.interpret(self.msg)
ttc = self.msg.task_to_compute
self.assertEqual(add_mock.call_count, 2)
call_inner = mock.call(
msg=self.msg.reject_report_computed_task,
node_id=ttc.requestor_id,
local_role=Actor.Provider,
remote_role=Actor.Requestor,
)
add_mock.assert_has_calls([
self.call_response,
call_inner,
])
def test_force_get_task_result_download_failed(self, log_mock):
fgtrd = self._get_correct_message()
library.interpret(fgtrd)
exception = Exception()
with mock.patch(
'golem.network.concent.filetransfers'
'.ConcentFiletransferService.download',
mock.Mock(side_effect=exception)):
self.cft._run()
log_mock.assert_called_with("Concent download failed: %r, %s",
self.rct.subtask_id, exception)
def test_concent_ack(self, add_mock):
self.msg.reason = self.reasons.ConcentAck
library.interpret(self.msg)
ttc = self.msg.task_to_compute
call_inner = mock.call(
msg=self.msg.ack_report_computed_task,
node_id=ttc.requestor_id,
local_role=Actor.Provider,
remote_role=Actor.Concent,
)
self.assertEqual(add_mock.call_count, 2)
add_mock.assert_has_calls([
self.call_response,
call_inner,
])
def test_force_get_task_result_upload_failed(self, log_mock):
fgtru = self._get_correct_message()
self.task_server.results_to_send[self.wtr.subtask_id] = self.wtr
library.interpret(fgtru)
exception = Exception()
with mock.patch(
'golem.network.concent.filetransfers'
'.ConcentFiletransferService.upload',
mock.Mock(side_effect=exception)):
self.cft._run()
log_mock.assert_called_with("Concent results upload failed: %r, %s",
fgtru.subtask_id, exception)
def test_force_get_task_result_failed(self, tcf):
fgtrf = msg_factories.concents.ForceGetTaskResultFailedFactory()
fgtrf._fake_sign()
library.interpret(fgtrf)
msg = history.MessageHistoryService.get_sync_as_message(
task=fgtrf.task_id,
subtask=fgtrf.subtask_id,
node=fgtrf.task_to_compute.provider_id,
msg_cls='ForceGetTaskResultFailed',
)
self.assertIsInstance(msg, message.concents.ForceGetTaskResultFailed)
tcf.assert_called_once_with(
fgtrf.subtask_id,
'Error downloading the task result through the Concent')
def test_force_get_task_result_download_extraction_failed(self, log_mock):
fgtrd = self._get_correct_message()
library.interpret(fgtrd)
exception = Exception()
extract = \
self.task_server.task_manager.task_result_manager.extract_zip = \
mock.Mock(side_effect=exception)
with mock.patch(
'golem.network.concent.filetransfers'
'.ConcentFiletransferService.download', ):
self.cft._run()
extract.assert_called_once()
log_mock.assert_called_with(
"Concent results extraction failure: %r, %s", fgtrd.subtask_id,
exception)
def test_force_subtask_results_response_accepted(self, add_mock):
msg = msg_factories.concents.\
ForceSubtaskResultsResponseFactory.with_accepted()
library.interpret(msg)
self.client.transaction_system.expect_income.assert_called_once_with(
msg.task_to_compute.requestor_id,
msg.subtask_id,
msg.task_to_compute.requestor_ethereum_address,
msg.task_to_compute.price,
msg.subtask_results_accepted.payment_ts,
)
add_mock.assert_called_once_with(
msg=msg.subtask_results_accepted,
node_id=mock.ANY,
local_role=Actor.Provider,
remote_role=Actor.Requestor,
)
def test_ack_subtask_results_verify(self, upload_mock):
self.task_server.results_to_send[self.wtr.subtask_id] = self.wtr
self.task_server.task_manager.comp_task_keeper.add_package_paths(
self.wtr.task_id, [self.path])
asrv = self.get_asrv()
library.interpret(asrv)
self.cft._run()
self.cft._run()
self.assertEqual(upload_mock.call_count, 2)
resources_call, results_call = upload_mock.call_args_list
self.assertEqual(resources_call[0][0].file_transfer_token,
asrv.file_transfer_token)
self.assertEqual(resources_call[0][0].file_category,
FileTransferToken.FileInfo.Category.resources)
self.assertEqual(results_call[0][0].file_transfer_token,
asrv.file_transfer_token)
self.assertEqual(results_call[0][0].file_category,
FileTransferToken.FileInfo.Category.results)
def test_force_get_task_result_upload(self, log_mock):
fgtru = self._get_correct_message()
self.task_server.results_to_send[self.wtr.subtask_id] = self.wtr
library.interpret(fgtru)
response = mock.Mock(ok=True)
with mock.patch(
'golem.network.concent.filetransfers'
'.ConcentFiletransferService.upload',
mock.Mock(return_value=response)) as upload_mock:
self.cft._run()
upload_mock.assert_called_once()
self.assertEqual(upload_mock.call_args[0][0].file_path,
self.wtr.package_path)
self.assertEqual(upload_mock.call_args[0][0].file_transfer_token,
fgtru.file_transfer_token)
log_mock.assert_called_with("Concent results upload sucessful: %r, %s",
fgtru.subtask_id, response)
def test_ftt_wrong_type(self, log_mock):
msg = self._get_message_ftt_wrong_type()
library.interpret(msg)
self.cf_transfer.assert_not_called()
log_mock.assert_called_once()
self.assertIn('File Transfer Token invalid', log_mock.call_args[0][0])
def test_force_get_task_result_upload_wtr_not_found(self, log_mock):
fgtru = self._get_correct_message()
library.interpret(fgtru)
self.cf_transfer.assert_not_called()
log_mock.assert_called_once()
self.assertIn('Cannot find the subtask', log_mock.call_args[0][0])
def test_no_sra_nor_srr(self, last_resort_mock, get_mock):
get_mock.return_value = None
library.interpret(self.msg)
last_resort_mock.assert_called_once_with(
report_computed_task=self.msg.ack_report_computed_task.
report_computed_task, )
def test_ack_subtask_results_verify_srv_not_ours(self, log_mock):
asrv = self.get_asrv(sign=False)
library.interpret(asrv)
self.assertIn('Signature invalid', log_mock.call_args[0][0])
def test_ack_subtask_results_verify_ftt_not_upload(self, log_mock):
asrv = self.get_asrv(file_transfer_token__operation=FileTransferToken.
Operation.download)
library.interpret(asrv)
self.assertIn('File Transfer Token invalid', log_mock.call_args[0][0])
def test_ack_subtask_results_verify_no_ftt(self, log_mock):
asrv = self.get_asrv(file_transfer_token=None)
library.interpret(asrv)
self.assertIn('File Transfer Token invalid', log_mock.call_args[0][0])
