def setUp(self):
super().setUp()
# Keys
(self.PROVIDER_PRIVATE_KEY,
self.PROVIDER_PUBLIC_KEY) = generate_ecc_key_pair()
(self.REQUESTOR_PRIVATE_KEY,
self.REQUESTOR_PUBLIC_KEY) = generate_ecc_key_pair()
(self.DIFFERENT_PROVIDER_PRIVATE_KEY,
self.DIFFERENT_PROVIDER_PUBLIC_KEY) = generate_ecc_key_pair()
(self.DIFFERENT_REQUESTOR_PRIVATE_KEY,
self.DIFFERENT_REQUESTOR_PUBLIC_KEY) = generate_ecc_key_pair()
(self.PROVIDER_PRIV_ETH_KEY,
self.PROVIDER_PUB_ETH_KEY) = generate_priv_and_pub_eth_account_key()
(self.REQUESTOR_PRIV_ETH_KEY,
self.REQUESTOR_PUB_ETH_KEY) = generate_priv_and_pub_eth_account_key()
(self.DIFFERENT_PROVIDER_PRIV_ETH_KEY,
self.DIFFERENT_PROVIDER_PUB_ETH_KEY
) = generate_priv_and_pub_eth_account_key()
(self.DIFFERENT_REQUESTOR_PRIV_ETH_KEY,
self.DIFFERENT_REQUESTOR_PUB_ETH_KEY
) = generate_priv_and_pub_eth_account_key()
# StoredMessage
self.stored_message_counter = 0
# Auth
self.auth_message_counter = 0
def setUp(self):
(self.PROVIDER_PRIVATE_KEY,
self.PROVIDER_PUBLIC_KEY) = generate_ecc_key_pair()
(self.REQUESTOR_PRIVATE_KEY,
self.REQUESTOR_PUBLIC_KEY) = generate_ecc_key_pair()
self.report_computed_task = tasks.ReportComputedTaskFactory(
sign__privkey=self.PROVIDER_PRIVATE_KEY,
task_to_compute=tasks.TaskToComputeFactory(
sign__privkey=self.REQUESTOR_PRIVATE_KEY, ))
store_report_computed_task_as_subtask(self.report_computed_task)
def test_case_multiple_force_subtask_results_does_not_cause_integrity_errors(
cluster_consts: ProtocolConstants,
cluster_url: str
) -> None:
clear_responses()
provider_private_key, provider_public_key = generate_ecc_key_pair()
requestor_private_key, requestor_public_key = generate_ecc_key_pair()
current_time = get_current_utc_timestamp()
signed_task_to_compute = create_signed_task_to_compute(
timestamp=calculate_timestamp(current_time, cluster_consts.concent_messaging_time, cluster_consts.minimum_upload_rate),
deadline=calculate_deadline(current_time, cluster_consts.concent_messaging_time, cluster_consts.minimum_upload_rate),
price=1000,
provider_public_key=provider_public_key,
provider_private_key=provider_private_key,
requestor_public_key=requestor_public_key,
requestor_private_key=requestor_private_key
)
report_computed_task = create_signed_report_computed_task(
task_to_compute=signed_task_to_compute,
provider_private_key=provider_private_key,
)
call_function_in_threads(
func=send_correct_force_subtask_results,
number_of_threads=NUMBER_OF_TESTING_THREADS,
cluster_url=cluster_url,
report_computed_task=report_computed_task,
current_time=current_time,
provider_private_key=provider_private_key,
requestor_private_key=requestor_private_key,
)
end_time = time.time() + MAXIMUM_WAITING_TIME_FOR_ALL_RESPONSES
while len(responses_global) != NUMBER_OF_TESTING_THREADS:
time.sleep(0.1)
if time.time() >= end_time:
break
expected_responses = ['ServiceRefused', 'ServiceRefused', 'ServiceRefused']
assert len(expected_responses) == NUMBER_OF_TESTING_THREADS, 'Did you change number of testing threads and forget to change expected_responses?'
print('Responses = ' + str(responses_global))
assert_content_equal(actual=responses_global, expected=expected_responses)
print('Single test passed successfully')
def test_that_incorrect_signature_raises_concent_validation_error(self):
different_provider_private_key, _ = generate_ecc_key_pair()
self.subtask_results_verify.sign_concent_promissory_note(
self.deposit_contract_address,
different_provider_private_key,
)
with pytest.raises(ConcentValidationError):
validate_subtask_results_verify(self.subtask_results_verify,
self.deposit_contract_address)
def setUp(self):
(REQUESTOR_ETHEREUM_PRIVATE_KEY,
REQUESTOR_ETHERUM_PUBLIC_KEY) = generate_ecc_key_pair()
self.task_to_compute = TaskToComputeFactory(
requestor_ethereum_public_key=encode_hex(
REQUESTOR_ETHERUM_PUBLIC_KEY))
self.task_to_compute.generate_ethsig(REQUESTOR_ETHEREUM_PRIVATE_KEY)
self.task_to_compute.sign_all_promissory_notes(
deposit_contract_address=settings.GNT_DEPOSIT_CONTRACT_ADDRESS,
private_key=REQUESTOR_ETHEREUM_PRIVATE_KEY,
)
def setUp(self):
super().setUp()
(self.PROVIDER_PRIVATE_KEY,
self.PROVIDER_PUBLIC_KEY) = generate_ecc_key_pair()
(self.REQUESTOR_PRIVATE_KEY,
self.REQUESTOR_PUBLIC_KEY) = generate_ecc_key_pair()
self.task_to_compute = TaskToComputeFactory()
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.ADDITIONAL_VERIFICATION,
next_deadline=get_current_utc_timestamp() +
settings.CONCENT_MESSAGING_TIME,
task_to_compute=self.task_to_compute,
report_computed_task=ReportComputedTaskFactory(
task_to_compute=self.task_to_compute, ))
def setUp(self):
self.provider_private_key, self.provider_public_key = generate_ecc_key_pair(
)
self.deposit_contract_address = '0xcfB81A6EE3ae6aD4Ac59ddD21fB4589055c13DaD'
want_to_compute_task = WantToComputeTaskFactory(
provider_public_key=encode_hex(self.provider_public_key))
arguments = {
'subtask_results_rejected__'
'report_computed_task__'
'task_to_compute__'
'want_to_compute_task':
want_to_compute_task
}
self.subtask_results_verify: SubtaskResultsVerify = SubtaskResultsVerifyFactory(
**arguments)
from golem_messages.factories.tasks import WantToComputeTaskFactory
from golem_messages.utils import encode_hex
from common.constants import ErrorCode
from common.helpers import get_current_utc_timestamp
from common.helpers import sign_message
from common.testing_helpers import generate_ecc_key_pair
from core.decorators import handle_errors_and_responses
from core.decorators import require_golem_message
from core.exceptions import Http400
from core.message_handlers import store_subtask
from core.models import Client
from core.models import Subtask
from core.utils import hex_to_bytes_convert
(CONCENT_PRIVATE_KEY, CONCENT_PUBLIC_KEY) = generate_ecc_key_pair()
(PROVIDER_PRIVATE_KEY, PROVIDER_PUBLIC_KEY) = generate_ecc_key_pair()
(PROVIDER_ETHEREUM_PRIVATE_KEY,
PROVIDER_ETHERUM_PUBLIC_KEY) = generate_ecc_key_pair()
(REQUESTOR_PRIVATE_KEY, REQUESTOR_PUBLIC_KEY) = generate_ecc_key_pair()
(REQUESTOR_ETHEREUM_PRIVATE_KEY,
REQUESTOR_ETHERUM_PUBLIC_KEY) = generate_ecc_key_pair()
class CustomException(Exception):
pass
@override_settings(
CONCENT_PRIVATE_KEY=CONCENT_PRIVATE_KEY,
CONCENT_PUBLIC_KEY=CONCENT_PUBLIC_KEY,
from golem_messages.message.tasks import TaskToCompute
from golem_messages.shortcuts import dump
from golem_messages.shortcuts import load
from golem_messages.utils import encode_hex
from common.helpers import parse_timestamp_to_utc_datetime
from common.helpers import sign_message
from common.testing_helpers import generate_ecc_key_pair
from concent_api.settings import GOLEM_MESSAGES_VERSION
from core.exceptions import UnexpectedResponse
from core.utils import calculate_maximum_download_time
from protocol_constants import get_protocol_constants
from protocol_constants import print_protocol_constants
from sci_testing_common import SCIBaseTest
(PROVIDER_PRIVATE_KEY, PROVIDER_PUBLIC_KEY) = generate_ecc_key_pair()
(REQUESTOR_PRIVATE_KEY, REQUESTOR_PUBLIC_KEY) = generate_ecc_key_pair()
REQUEST_HEADERS = {
'Content-Type': 'application/octet-stream',
'X-Golem-Messages': GOLEM_MESSAGES_VERSION
}
REPORT_COMPUTED_TASK_SIZE = 10
class TestAssertionException(Exception):
pass
class count_fails(object):
def _get_or_generate_keys(party: str) -> Tuple:
if are_keys_predifined(party):
return _get_predefined_keys(party)
return generate_ecc_key_pair()
from core.constants import MESSAGE_TASK_ID_MAX_LENGTH from core.exceptions import FrameNumberValidationError from core.exceptions import HashingAlgorithmError from core.subtask_helpers import are_keys_and_addresses_unique_in_message_subtask_results_accepted from core.subtask_helpers import are_subtask_results_accepted_messages_signed_by_the_same_requestor from core.tests.utils import ConcentIntegrationTestCase from core.validation import validate_all_messages_identical from core.validation import validate_compute_task_def from core.validation import validate_ethereum_addresses from core.validation import validate_golem_message_subtask_results_rejected from core.validation import validate_id_value from core.validation import validate_frames from core.validation import validate_positive_integer_value from core.validation import validate_scene_file (CONCENT_PRIVATE_KEY, CONCENT_PUBLIC_KEY) = generate_ecc_key_pair() (PROVIDER_PRIVATE_KEY, PROVIDER_PUBLIC_KEY) = generate_ecc_key_pair() (REQUESTOR_PRIVATE_KEY, REQUESTOR_PUBLIC_KEY) = generate_ecc_key_pair() (DIFFERENT_PROVIDER_PRIVATE_KEY, DIFFERENT_PROVIDER_PUBLIC_KEY) = generate_ecc_key_pair() (DIFFERENT_REQUESTOR_PRIVATE_KEY, DIFFERENT_REQUESTOR_PUBLIC_KEY) = generate_ecc_key_pair() (PROVIDER_PRIV_ETH_KEY, PROVIDER_PUB_ETH_KEY) = generate_priv_and_pub_eth_account_key() (REQUESTOR_PRIV_ETH_KEY, REQUESTOR_PUB_ETH_KEY) = generate_priv_and_pub_eth_account_key() (DIFFERENT_PROVIDER_PRIV_ETH_KEY, DIFFERENT_PROVIDER_PUB_ETH_KEY) = generate_priv_and_pub_eth_account_key() (DIFFERENT_REQUESTOR_PRIV_ETH_KEY, DIFFERENT_REQUESTOR_PUB_ETH_KEY) = generate_priv_and_pub_eth_account_key()
from golem_messages import message
from golem_messages.factories import tasks
from golem_messages.shortcuts import dump
from golem_messages.shortcuts import load
from common.exceptions import ConcentValidationError
from common.shortcuts import load_without_public_key
from common.testing_helpers import generate_ecc_key_pair
from core.exceptions import Http400
from core.tests.utils import generate_uuid_for_tests
from core.validation import validate_that_golem_messages_are_signed_with_key
from core.validation import validate_all_messages_identical
(CONCENT_PRIVATE_KEY, CONCENT_PUBLIC_KEY) = generate_ecc_key_pair()
(REQUESTOR_PRIVATE_KEY, REQUESTOR_PUBLIC_KEY) = generate_ecc_key_pair()
@override_settings(
CONCENT_PRIVATE_KEY = CONCENT_PRIVATE_KEY,
CONCENT_PUBLIC_KEY = CONCENT_PUBLIC_KEY,
)
class LoadWithoutPublicKeyUnitTest(TestCase):
def test_load_without_public_key_should_load_message(self):
"""
Test that message loaded with load_without_public_key function will be the same as load
with golem_messages load function.
"""
def setUp(self):
self.message = "Missing 'Authorization' header."
self.path = 'blender/benchmark/test_task/scene-Helicopter-27-cycles.blend'
self.client_key = b64encode(generate_ecc_key_pair()[1]).decode("ascii")
from assertpy import assert_that
from django.conf import settings
from django.test import override_settings
from common.testing_helpers import generate_ecc_key_pair
from concent_api.system_check import check_signing_service_key_availability_for_middleman
from concent_api.system_check import create_error_32_signing_service_public_key_is_missing
from concent_api.system_check import create_error_33_signing_service_public_key_is_invalid
(_, SIGNING_SERVICE_PUBLIC_KEY) = generate_ecc_key_pair()
class TestCheckSigningServiceKeyAvailabilityForMiddleMan: # pylint: disable=no-self-use
def test_that_if_middleman_is_disabled_signing_service_public_key_does_not_have_to_be_defined_in_settings(
self):
with override_settings(CONCENT_FEATURES=[]):
errors = check_signing_service_key_availability_for_middleman()
assert_that(errors).is_empty()
@override_settings()
def test_that_if_middleman_is_enabled_and_signing_service_public_key_is_not_defined_error_is_returned(
self):
del settings.SIGNING_SERVICE_PUBLIC_KEY
errors = check_signing_service_key_availability_for_middleman()
assert_that(errors).is_length(1)
assert_that(errors[0]).is_equal_to(
create_error_32_signing_service_public_key_is_missing())
def test_that_if_middleman_is_enabled_and_valid_signing_service_public_key_is_defined_no_errors_are_returned(
self):
with override_settings(
from django.test import override_settings
import mock
from web3 import Web3
from common.testing_helpers import generate_ecc_key_pair
from common.helpers import get_current_utc_timestamp
from core.constants import MOCK_TRANSACTION_HASH
from core.payments.backends import sci_backend
from core.tests.utils import ConcentIntegrationTestCase
(CONCENT_PRIVATE_KEY, CONCENT_PUBLIC_KEY) = generate_ecc_key_pair()
(DIFFERENT_CONCENT_PRIVATE_KEY, DIFFERENT_CONCENT_PUBLIC_KEY) = generate_ecc_key_pair()
(SIGNING_SERVICE_PRIVATE_KEY, SIGNING_SERVICE_PUBLIC_KEY) = generate_ecc_key_pair()
@override_settings(
CONCENT_ETHEREUM_PUBLIC_KEY='b51e9af1ae9303315ca0d6f08d15d8fbcaecf6958f037cc68f9ec18a77c6f63eae46daaba5c637e06a3e4a52a2452725aafba3d4fda4e15baf48798170eb7412',
GETH_ADDRESS='http://localhost:5555/',
GNT_DEPOSIT_CONTRACT_ADDRESS='0xcfB81A6EE3ae6aD4Ac59ddD21fB4589055c13DaD',
)
class SCIBackendTest(ConcentIntegrationTestCase):
def setUp(self):
super().setUp()
self.task_to_compute = self._get_deserialized_task_to_compute()
self.current_time = get_current_utc_timestamp()
self.last_block = 8
self.block_number = 10
def _create_client_mock_and_return_none(*_args, **_kwargs) -> None:
number_of_clients = Client.objects.count()
Client.objects.create(public_key_bytes=generate_ecc_key_pair()[1])
assert Client.objects.count() == number_of_clients + 1
return None
from django.test import override_settings
from django.test import TestCase
from django.urls import reverse
from golem_messages.shortcuts import dump
from golem_messages import message
from common.testing_helpers import generate_ecc_key_pair
(CONCENT_PRIVATE_KEY, CONCENT_PUBLIC_KEY) = generate_ecc_key_pair()
(PROVIDER_PRIVATE_KEY, PROVIDER_PUBLIC_KEY) = generate_ecc_key_pair()
@override_settings(
CONCENT_PRIVATE_KEY=CONCENT_PRIVATE_KEY,
CONCENT_PUBLIC_KEY=CONCENT_PUBLIC_KEY,
CONCENT_MESSAGING_TIME=10, # seconds
)
class ApiViewsIntegrationTest(TestCase):
def setUp(self):
self.dummy_message_to_concent = message.Ping()
self.serialized_dummy_message_to_concent = dump(
self.dummy_message_to_concent, PROVIDER_PRIVATE_KEY,
CONCENT_PUBLIC_KEY)
def test_any_message_to_concent_report_empty_content_type_returns_400_error(
self):
"""
Tests if any golem message to Concent will return HTTP 400 error
if content_type is missing in header.
"""
from middleman_protocol.exceptions import PayloadTypeInvalidMiddlemanProtocolError
from middleman_protocol.exceptions import SignatureInvalidMiddlemanProtocolError
from middleman_protocol.message import AbstractFrame
from middleman_protocol.message import AuthenticationChallengeFrame
from middleman_protocol.message import AuthenticationResponseFrame
from middleman_protocol.message import ErrorFrame
from middleman_protocol.message import GolemMessageFrame
from middleman_protocol.message import HeartbeatFrame
from middleman_protocol.registry import create_middleman_protocol_message
from middleman_protocol.stream import append_frame_separator
from middleman_protocol.stream import escape_encode_raw_message
from middleman_protocol.tests.utils import async_stream_actor_mock
from middleman_protocol.tests.utils import prepare_mocked_reader
from middleman_protocol.tests.utils import prepare_mocked_writer
(CONCENT_PRIVATE_KEY, CONCENT_PUBLIC_KEY) = generate_ecc_key_pair()
(SIGNING_SERVICE_PRIVATE_KEY, SIGNING_SERVICE_PUBLIC_KEY) = generate_ecc_key_pair()
(WRONG_SIGNING_SERVICE_PRIVATE_KEY, WRONG_SIGNING_SERVICE_PUBLIC_KEY) = generate_ecc_key_pair()
FROZEN_DATE_AND_TIME = "2012-01-14 12:00:01"
FROZEN_TIMESTAMP = parse_datetime_to_timestamp(datetime.datetime.strptime(FROZEN_DATE_AND_TIME, "%Y-%m-%d %H:%M:%S"))
async def get_item(queue):
await sleep(0.000001)
item = await queue.get()
queue.task_done()
return item
def _get_mocked_reader(message, request_id, sign_as, **kwargs):
protocol_message = create_middleman_protocol_message(PayloadType.GOLEM_MESSAGE, message, request_id)
