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)