def test_tx_failure(self, score_invoke): score_invoke.side_effect = Mock( side_effect=InvalidParamsException("error")) from_ = Address.from_data(AddressPrefix.EOA, os.urandom(20)) to_ = Address.from_data(AddressPrefix.CONTRACT, os.urandom(20)) tx_index = randrange(0, 100) self._mock_context.tx = Transaction(os.urandom(32), tx_index, from_, to_, 0) self._mock_context.msg = Message(from_) self._mock_context.tx_batch = TransactionBatch() raise_exception_start_tag("test_tx_failure") tx_result = self._icon_service_engine._handle_icx_send_transaction( self._mock_context, { 'from': from_, 'to': to_ }) raise_exception_end_tag("test_tx_failure") self._icon_service_engine._charge_transaction_fee.assert_called() self.assertEqual(0, tx_result.status) self.assertEqual(tx_index, tx_result.tx_index) self.assertIsNone(tx_result.score_address) camel_dict = tx_result.to_dict(to_camel_case) self.assertNotIn('scoreAddress', camel_dict)
def test_tx_success(self): from_ = Address.from_data(AddressPrefix.EOA, os.urandom(20)) to_ = Address.from_data(AddressPrefix.EOA, os.urandom(20)) tx_index = randrange(0, 100) self._mock_context.tx = Transaction(os.urandom(32), tx_index, from_, to_, 0) self._mock_context.msg = Message(from_) params = { 'version': 3, 'from': from_, 'to': to_, 'value': 0, 'timestamp': 1234567890, 'nonce': 1 } self._icon_service_engine._process_transaction = Mock( return_value=None) tx_result = self._icon_service_engine._handle_icx_send_transaction( self._mock_context, params) self._icon_service_engine._charge_transaction_fee.assert_called() self.assertEqual(1, tx_result.status) self.assertEqual(tx_index, tx_result.tx_index) self.assertEqual(to_, tx_result.to) self.assertIsNone(tx_result.score_address) camel_dict = tx_result.to_dict(to_camel_case) self.assertNotIn('failure', camel_dict) self.assertNotIn('scoreAddress', camel_dict)
def test_from_dict_with_transfer_event_log(self): signature = "Transfer(Address,Address,int)" score_address = Address.from_string( "cx4d6f646441a3f9c9b91019c9b98e3c342cceb114" ) indexed_address_0 = Address.from_data(AddressPrefix.EOA, b"address0") indexed_address_1 = Address.from_data(AddressPrefix.EOA, b"address1") value = 0x8AC7230489E80000 event_log_data = { "scoreAddress": str(score_address), "indexed": [ signature, str(indexed_address_0), str(indexed_address_1), hex(value), ], "data": [], } event_log = EventLog.from_dict(event_log_data) assert event_log.signature == signature assert event_log.score_address == score_address assert event_log.indexed[0] == signature assert len(event_log.indexed) == 4 assert event_log.indexed[1] == indexed_address_0 assert event_log.indexed[2] == indexed_address_1 assert event_log.indexed[3] == value assert len(event_log.data) == 0
def test_sample_result(self): from_ = Address.from_data(AddressPrefix.EOA, b'from') to_ = Address.from_data(AddressPrefix.CONTRACT, b'to') self._mock_context.tx = Transaction(os.urandom(32), 1234, from_, to_, 0) self._mock_context.msg = Message(from_) IconScoreContext.engine.deploy.invoke = Mock() self._icon_service_engine._process_transaction = Mock(return_value=to_) tx_result = self._icon_service_engine._handle_icx_send_transaction( self._mock_context, { 'from': from_, 'to': to_ }) tx_result.score_address = to_ tx_result.event_logs = [ EventLog( Address.from_data(AddressPrefix.CONTRACT, b'addr_to'), [b'indexed', Address.from_data(AddressPrefix.EOA, b'index')], [True, 1234, 'str', None, b'test']) ] tx_result.logs_bloom = BloomFilter() tx_result.logs_bloom.add(b'1') tx_result.logs_bloom.add(b'2') tx_result.logs_bloom.add(b'3') tx_result.block = Block(123, hashlib.sha3_256(b'block').digest(), 1, None, 0) camel_dict = tx_result.to_dict(to_camel_case) self.assertIn('txHash', camel_dict) self.assertIn('blockHeight', camel_dict) self.assertIn('txIndex', camel_dict) self.assertIn('to', camel_dict) self.assertIn('scoreAddress', camel_dict) self.assertIn('stepUsed', camel_dict) self.assertIn('stepPrice', camel_dict) self.assertIn('eventLogs', camel_dict) self.assertIn('logsBloom', camel_dict) self.assertIn('status', camel_dict) self.assertEqual(1, len(camel_dict['eventLogs'])) self.assertIn('scoreAddress', camel_dict['eventLogs'][0]) self.assertIn('indexed', camel_dict['eventLogs'][0]) self.assertIn('data', camel_dict['eventLogs'][0]) self.assertEqual(256, len(camel_dict['logsBloom'])) converted_result = TypeConverter.convert_type_reverse(camel_dict) self.assertFalse(converted_result['txHash'].startswith('0x')) self.assertTrue(converted_result['blockHeight'].startswith('0x')) self.assertTrue(converted_result['txIndex'].startswith('0x')) self.assertTrue(converted_result['to'].startswith('cx')) self.assertTrue(converted_result['scoreAddress'].startswith('cx')) self.assertTrue(converted_result['stepUsed'].startswith('0x')) self.assertTrue(converted_result['logsBloom'].startswith('0x')) self.assertTrue(converted_result['status'].startswith('0x'))
def test_sample_result(self): from_ = Address.from_data(AddressPrefix.EOA, b'from') to_ = Address.from_data(AddressPrefix.CONTRACT, b'to') self._mock_context.tx.index = 1234 self._mock_context.tx.hash = hashlib.sha256(b'hash').digest() self._icon_service_engine._icon_score_deploy_engine.attach_mock( Mock(return_value=False), 'is_data_type_supported') tx_result = self._icon_service_engine._handle_icx_send_transaction( self._mock_context, {'from': from_, 'to': to_}) tx_result.score_address = \ Address.from_data(AddressPrefix.CONTRACT, b'score_address') tx_result.event_logs = [ EventLog( Address.from_data(AddressPrefix.CONTRACT, b'addr_to'), [b'indexed', Address.from_data(AddressPrefix.EOA, b'index')], [True, 1234, 'str', None, b'test'] ) ] tx_result.logs_bloom = BloomFilter() tx_result.logs_bloom.add(b'1') tx_result.logs_bloom.add(b'2') tx_result.logs_bloom.add(b'3') tx_result.block = Block(123, hashlib.sha256(b'block').digest(), 1, None) camel_dict = tx_result.to_dict(to_camel_case) self.assertIn('txHash', camel_dict) self.assertIn('blockHeight', camel_dict) self.assertIn('txIndex', camel_dict) self.assertIn('to', camel_dict) self.assertIn('scoreAddress', camel_dict) self.assertIn('stepUsed', camel_dict) self.assertIn('stepPrice', camel_dict) self.assertIn('eventLogs', camel_dict) self.assertIn('logsBloom', camel_dict) self.assertIn('status', camel_dict) self.assertEqual(1, len(camel_dict['eventLogs'])) self.assertIn('scoreAddress', camel_dict['eventLogs'][0]) self.assertIn('indexed', camel_dict['eventLogs'][0]) self.assertIn('data', camel_dict['eventLogs'][0]) self.assertEqual(256, len(camel_dict['logsBloom'])) converted_result = TypeConverter.convert_type_reverse(camel_dict) self.assertFalse(converted_result['txHash'].startswith('0x')) self.assertTrue(converted_result['blockHeight'].startswith('0x')) self.assertTrue(converted_result['txIndex'].startswith('0x')) self.assertTrue(converted_result['to'].startswith('cx')) self.assertTrue(converted_result['scoreAddress'].startswith('cx')) self.assertTrue(converted_result['stepUsed'].startswith('0x')) self.assertTrue(converted_result['logsBloom'].startswith('0x')) self.assertTrue(converted_result['status'].startswith('0x'))
def test_revert(self, mocker): mocker.patch.object(IconServiceEngine, "_charge_transaction_fee") mocker.patch.object(IconScoreEngine, "invoke") context = ContextContainer._get_context() icon_service_engine = IconServiceEngine() icon_service_engine._icx_engine = Mock(spec=IcxEngine) icon_service_engine._icon_score_deploy_engine = \ Mock(spec=DeployEngine) icon_service_engine._icon_pre_validator = Mock(spec=IconPreValidator) context.tx_batch = TransactionBatch() context.clear_batch = Mock() context.update_batch = Mock() from_ = Address.from_data(AddressPrefix.EOA, os.urandom(20)) to_ = Address.from_data(AddressPrefix.CONTRACT, os.urandom(20)) tx_index = randrange(0, 100) context.tx = Transaction(os.urandom(32), tx_index, from_, 0) context.msg = Message(from_) def intercept_charge_transaction_fee(*args, **kwargs): return {}, Mock(spec=int) IconServiceEngine._charge_transaction_fee.side_effect = \ intercept_charge_transaction_fee icon_service_engine._icon_score_deploy_engine.attach_mock( Mock(return_value=False), 'is_data_type_supported') reason = Mock(spec=str) code = ExceptionCode.SCORE_ERROR mock_revert = Mock(side_effect=IconScoreException(reason)) IconScoreEngine.invoke.side_effect = mock_revert raise_exception_start_tag("test_revert") tx_result = icon_service_engine._handle_icx_send_transaction( context, { 'version': 3, 'from': from_, 'to': to_ }) raise_exception_end_tag("test_revert") assert tx_result.status == 0 IconServiceEngine._charge_transaction_fee.assert_called() context.traces.append.assert_called() trace = context.traces.append.call_args[0][0] assert trace.trace == TraceType.REVERT assert trace.data[0] == code assert trace.data[1] == reason
def make_origin_parameters(option: dict = None) -> dict: params = make_required_parameters( version=hex(3), _from=str(Address.from_data(AddressPrefix.EOA, os.urandom(20))), to=str(Address.from_data(random.choice([AddressPrefix.EOA, AddressPrefix.CONTRACT]), os.urandom(20))), stepLimit=hex(random.randint(10, 5000)), timestamp=hex(random.randint(10, 5000)), signature='VAia7YZ2Ji6igKWzjR2YsGa2m53nKPrfK7uXYW78QLE+ATehAVZPC40szvAiA6NEU5gCYB4c4qaQzqDh2ugcHgA=' ) if option: params.update(option) return params
def setUp(self) -> None: self.converter = PRepAddressConverter() self.node_addresses = [] self.prep_addresses = [] # Generate sample addresses for test for i in range(10): node_address = Address.from_data( AddressPrefix.EOA, f'node_address{i}'.encode("utf-8")) prep_address = Address.from_data( AddressPrefix.EOA, f'prep_address{i}'.encode("utf-8")) self.node_addresses.append(node_address) self.prep_addresses.append(prep_address)
def test_call_event_kwarg(self): context = ContextContainer._get_context() name = "name" address = Address.from_data(AddressPrefix.EOA, b'address') age = 10 # Call with ordered arguments self._mock_score.OneIndexEvent(name, address, age) self.assertEqual(len(context.event_logs), 1) event_log_ordered_args = context.event_logs[0] # Call with ordered arguments and keyword arguments self._mock_score.OneIndexEvent(name, age=age, address=address) self.assertEqual(len(context.event_logs), 2) event_log_keyword_args = context.event_logs[1] self.assertEqual(event_log_ordered_args.score_address, event_log_keyword_args.score_address) self.assertEqual(event_log_ordered_args.indexed, event_log_keyword_args.indexed) self.assertEqual(event_log_ordered_args.data, event_log_keyword_args.data) logs_bloom = IconServiceEngine._generate_logs_bloom(context.event_logs) one_event_bloom_data = \ int(0).to_bytes(1, DATA_BYTE_ORDER) + \ 'OneIndexEvent(str,Address,int)'.encode('utf-8') self.assertIn(one_event_bloom_data, logs_bloom) name_bloom_data = int(1).to_bytes( 1, DATA_BYTE_ORDER) + name.encode('utf-8') self.assertIn(name_bloom_data, logs_bloom)
def test_address_index_event(self): context = ContextContainer._get_context() address = Address.from_data(AddressPrefix.EOA, os.urandom(20)) # Tests simple event emit self._mock_score.AddressIndexEvent(address) self.assertEqual(1, len(context.event_logs)) event_log = context.event_logs[0] self.assertEqual(2, len(event_log.indexed)) self.assertEqual(0, len(event_log.data)) logs_bloom = IconServiceEngine._generate_logs_bloom(context.event_logs) # Asserts whether the SCORE address is included in the bloom self.assert_score_address_in_bloom(logs_bloom) event_bloom_data = \ int(0).to_bytes(1, DATA_BYTE_ORDER) + \ 'AddressIndexEvent(Address)'.encode('utf-8') self.assertIn(event_bloom_data, logs_bloom) indexed_bloom_data = int(1).to_bytes(1, DATA_BYTE_ORDER) + \ address.prefix.value.to_bytes(1, DATA_BYTE_ORDER) + address.body self.assertEqual(ICON_ADDRESS_BYTES_SIZE + 1, len(indexed_bloom_data)) self.assertIn(indexed_bloom_data, logs_bloom)
def test_install_result(self): self._icon_service_engine._icon_score_deploy_engine.attach_mock( Mock(return_value=True), 'is_data_type_supported') from_ = Address.from_data(AddressPrefix.EOA, b'test') tx_index = Mock(spec=int) self._mock_context.tx.attach_mock(tx_index, "index") self._mock_context.tx.timestamp = 0 self._mock_context.tx.origin = from_ self._mock_context.tx.nonce = None tx_result = self._icon_service_engine._handle_icx_send_transaction( self._mock_context, { 'version': 3, 'from': from_, 'to': ZERO_SCORE_ADDRESS, 'dataType': 'deploy', 'timestamp': 0, 'data': { 'contentType': 'application/tbears', 'content': '/home/haha' } } ) self._icon_service_engine._charge_transaction_fee.assert_called() self.assertEqual(1, tx_result.status) self.assertEqual(tx_index, tx_result.tx_index) self.assertEqual(ZERO_SCORE_ADDRESS, tx_result.to) self.assertIsNotNone(tx_result.score_address) camel_dict = tx_result.to_dict(to_camel_case) self.assertNotIn('failure', camel_dict)
def setUp(self): address = Address.from_data(AddressPrefix.CONTRACT, os.urandom(20)) db = Mock(spec=IconScoreDatabase) db.attach_mock(address, 'address') context = IconScoreContext() traces = Mock(spec=list) step_counter = Mock(spec=IconScoreStepCounter) IconScoreContext.engine = ContextEngine(icx=Mock(IcxEngine), deploy=Mock(DeployEngine), fee=None, iiss=None, prep=None, issue=None) IconScoreContext.storage = ContextStorage(icx=Mock(IcxStorage), deploy=Mock(DeployStorage), fee=None, iiss=None, prep=None, issue=None, rc=None, meta=None) IconScoreContext.icx_engine = Mock(spec=IcxEngine) context.type = IconScoreContextType.INVOKE context.func_type = IconScoreFuncType.WRITABLE context.tx_batch = TransactionBatch() context.event_logs = [] context.traces = traces context.step_counter = step_counter context.get_owner = Mock() ContextContainer._push_context(context) self._mock_score = EventlogScore(db)
def test_reserved_event_log(self): context = ContextContainer._get_context() context.func_type = IconScoreFuncType.READONLY address = Address.from_data(AddressPrefix.EOA, os.urandom(20)) with self.assertRaises(InvalidEventLogException): self._mock_score.ICXTransfer(address, address, 0)
def test_throw(self, score_invoke, IconServiceEngine_charge_transaction_fee): context = ContextContainer._get_context() self._icon_service_engine = IconServiceEngine() self._icon_service_engine._icx_engine = Mock(spec=IcxEngine) self._icon_service_engine._icon_score_deploy_engine = \ Mock(spec=DeployEngine) self._icon_service_engine._icon_pre_validator = Mock( spec=IconPreValidator) context.tx_batch = TransactionBatch() context.clear_batch = Mock() context.update_batch = Mock() from_ = Address.from_data(AddressPrefix.EOA, os.urandom(20)) to_ = Address.from_data(AddressPrefix.CONTRACT, os.urandom(20)) tx_index = randrange(0, 100) context.tx = Transaction(os.urandom(32), tx_index, from_, 0) context.msg = Message(from_) def intercept_charge_transaction_fee(*args, **kwargs): return {}, Mock(spec=int) IconServiceEngine_charge_transaction_fee.side_effect = \ intercept_charge_transaction_fee self._icon_service_engine._icon_score_deploy_engine.attach_mock( Mock(return_value=False), 'is_data_type_supported') error = Mock(spec=str) code = ExceptionCode.INVALID_PARAMETER mock_exception = Mock(side_effect=InvalidParamsException(error)) score_invoke.side_effect = mock_exception raise_exception_start_tag("test_throw") tx_result = self._icon_service_engine._handle_icx_send_transaction( context, {'version': 3, 'from': from_, 'to': to_}) raise_exception_end_tag("test_throw") self.assertEqual(0, tx_result.status) IconServiceEngine_charge_transaction_fee.assert_called() context.traces.append.assert_called() trace = context.traces.append.call_args[0][0] self.assertEqual(TraceType.THROW, trace.trace) self.assertEqual(code, trace.data[0]) self.assertEqual(error, trace.data[1])
def setUp(self): self._inner_task = generate_inner_task(Revision.FOUR.value) self.from_ = Address.from_data(AddressPrefix.EOA, os.urandom(20)) self.to = Address.from_string('cx' + '0' * 40) self.score = Address.from_string('cx' + '1' * 40) IconScoreContext.engine.icx.transfer = Mock() IconScoreContext.engine.icx.get_balance = Mock(return_value=5000) IconScoreContext.engine.prep.preps = Mock()
def test_send_icx_without_data(self): step_price = 10**10 default_step_cost = 100_000 input_step_cost = 200 value = 10**18 self._update_governance("0_0_6") for revision in range(REVISION_2, LATEST_REVISION + 1): self._set_revision_to_governance(revision, name="") # Create a new to address every block to = Address.from_data(AddressPrefix.EOA, f"to{revision}".encode()) genesis_balance0: int = self._query({"address": self._genesis}, 'icx_getBalance') self.assertTrue(genesis_balance0 > 0) # Check "to" address balance. It should be 0 to_balance0: int = self._query({"address": to}, 'icx_getBalance') self.assertEqual(0, to_balance0) if revision == REVISION_3: # Check backward compatibility on TestNet Database # step_used increases by input_step_cost * len(json.dumps(None)) # because of None parameter handling error on get_input_data_size() step_limit = default_step_cost + input_step_cost * len( json.dumps(None)) self.assertEqual(default_step_cost + input_step_cost * 4, step_limit) else: step_limit = default_step_cost tx = self._make_icx_send_tx(self._genesis, to, value=value, step_limit=step_limit) prev_block, tx_results = self._make_and_req_block([tx]) self._write_precommit_state(prev_block) tx_result: 'TransactionResult' = tx_results[0] self.assertEqual(1, tx_result.status) self.assertEqual(step_limit, tx_result.step_used) self.assertEqual(to, tx_result.to) self.assertIsNone(tx_result.failure) self.assertIsNone(tx_result.score_address) fee: int = tx_result.step_used * step_price self.assertTrue(fee > 0) to_balance: int = self._query({"address": to}, 'icx_getBalance') self.assertEqual(value, to_balance) genesis_balance1: int = self._query({"address": self._genesis}, 'icx_getBalance') self.assertEqual(genesis_balance0, genesis_balance1 + value + fee)
def test_put_and_get(self): """ """ context = self.context address = Address.from_data(AddressPrefix.CONTRACT, b'score') value = 100 self.context_db._put(context, address.body, value.to_bytes(32, 'big'), True) value = self.context_db.get(context, address.body) self.assertEqual(100, int.from_bytes(value, 'big'))
def test_deposit_fee_invalid_param(self): context = self.get_context() tx_hash = os.urandom(32) amount = randrange(FeeEngine._MIN_DEPOSIT_AMOUNT, FeeEngine._MAX_DEPOSIT_AMOUNT) block_height = randrange(100, 10000) term = get_rand_term() # invalid amount (underflow) # noinspection PyTypeChecker with self.assertRaises(InvalidRequestException) as e: inv_amount = randrange(0, FeeEngine._MIN_DEPOSIT_AMOUNT - 1) self._engine.add_deposit(context, tx_hash, self._sender, self._score_address, inv_amount, block_height, term) # noinspection PyUnresolvedReferences self.assertEqual('Invalid deposit amount', e.exception.message) # invalid amount (overflow) # noinspection PyTypeChecker with self.assertRaises(InvalidRequestException) as e: inv_amount = \ randrange(FeeEngine._MAX_DEPOSIT_AMOUNT + 1, FeeEngine._MAX_DEPOSIT_AMOUNT * 10) self._engine.add_deposit(context, tx_hash, self._sender, self._score_address, inv_amount, block_height, term) # noinspection PyUnresolvedReferences self.assertEqual('Invalid deposit amount', e.exception.message) # invalid term (underflow) # noinspection PyTypeChecker with self.assertRaises(InvalidRequestException) as e: inv_term = randrange(0, FeeEngine._MIN_DEPOSIT_TERM - 1) self._engine.add_deposit(context, tx_hash, self._sender, self._score_address, amount, block_height, inv_term) # noinspection PyUnresolvedReferences self.assertEqual('Invalid deposit term', e.exception.message) # invalid term (overflow) # noinspection PyTypeChecker with self.assertRaises(InvalidRequestException) as e: inv_term = \ randrange(FeeEngine._MAX_DEPOSIT_TERM + 1, FeeEngine._MAX_DEPOSIT_TERM * 10) self._engine.add_deposit(context, tx_hash, self._sender, self._score_address, amount, block_height, inv_term) # noinspection PyUnresolvedReferences self.assertEqual('Invalid deposit term', e.exception.message) # invalid owner # noinspection PyTypeChecker with self.assertRaises(InvalidRequestException) as e: inv_sender = Address.from_data(AddressPrefix.EOA, os.urandom(20)) self._engine.add_deposit(context, tx_hash, inv_sender, self._score_address, amount, block_height, term) # noinspection PyUnresolvedReferences self.assertEqual('Invalid SCORE owner', e.exception.message)
def test_handle_system_call_with_kwargs(self): from_ = GOVERNANCE_ADDRESS score_address = Address.from_data(AddressPrefix.CONTRACT, os.urandom(20)) args = {'address': score_address} system_call_handler.handle_system_call(self.context, from_, 0, 'getScoreDepositInfo', None, args) self.context.engine.fee.get_deposit_info.assert_called_with( self.context, score_address, self.block_height)
def test_icx_transfer_event(self): context = ContextContainer._get_context() address = Address.from_data(AddressPrefix.EOA, os.urandom(20)) # Tests simple event emit self._mock_score.icx.send(address, 1) self.assertEqual(len(context.event_logs), 1) event_log = context.event_logs[0] self.assertEqual(4, len(event_log.indexed)) self.assertEqual(ICX_TRANSFER_EVENT_LOG, event_log.indexed[0]) self.assertEqual(0, len(event_log.data))
def setUp(self): state_db_root_path = 'state_db' self.state_db_root_path = state_db_root_path rmtree(state_db_root_path) os.mkdir(state_db_root_path) address = Address.from_data(AddressPrefix.CONTRACT, b'0') db_path = os.path.join(state_db_root_path, 'db') context_db = ContextDatabase.from_path(db_path, True) self.db = IconScoreDatabase(address, context_db=context_db, prefix=b'') self.address = address
def test_handle_system_call_with_invalid_kwargs(self): from_ = GOVERNANCE_ADDRESS score_address = Address.from_data(AddressPrefix.CONTRACT, os.urandom(20)) args = {'address1': score_address} # noinspection PyTypeChecker with self.assertRaises(InvalidParamsException) as e: assert e is not None system_call_handler.handle_system_call(self.context, from_, 0, 'getScoreDepositInfo', None, args) self.context.engine.fee.get_deposit_info.assert_not_called()
def setUp(self): context = IconScoreContext(IconScoreContextType.DIRECT) block = Mock(spec=Block) block.attach_mock(Mock(return_value=0), 'height') context.block = block self._sender = Address.from_data(AddressPrefix.EOA, os.urandom(20)) self._score_address = Address.from_data(AddressPrefix.CONTRACT, os.urandom(20)) context_db = create_context_db() self.deploy_storage = DeployStorage(context_db) deploy_info = IconScoreDeployInfo(self._score_address, DeployState.ACTIVE, self._sender, os.urandom(32), os.urandom(32)) self.icx_storage = IcxStorage(context_db) self._icx_engine = IcxEngine() self.fee_storage = FeeStorage(context_db) patch_fee_storage(self.fee_storage) self.deploy_storage.put_deploy_info(context, deploy_info) context.storage = ContextStorage(deploy=self.deploy_storage, fee=self.fee_storage, icx=self.icx_storage, iiss=None, prep=None, issue=None, rc=None, meta=None) context.engine = ContextEngine(deploy=None, fee=None, icx=self._icx_engine, iiss=None, prep=None, issue=None) self._icx_engine.open(self.icx_storage) self.icx_storage._put_genesis_data_account(context, CoinPartType.GENERAL, self._sender, 100000000 * 10 ** 18) self.icx_storage._put_genesis_data_account(context, CoinPartType.TREASURY, Address.from_data(AddressPrefix.EOA, os.urandom(20)), 0) self._engine = FeeEngine()
def test_freeze(create_prep_container): size: int = 100 preps: 'PRepContainer' = create_prep_container(size) preps.freeze() i = random.randint(0, size - 1) prep = preps.get_by_index(i) with pytest.raises(AccessDeniedException): address = Address.from_data(AddressPrefix.EOA, os.urandom(20)) preps.add(PRep(address)) with pytest.raises(AccessDeniedException): preps.remove(prep.address)
def setUp(self): self.mem_db = {} self.key_ = b"key1" self.last_value = None def get(caller, key): return self.last_value score_address = Address.from_data(AddressPrefix.CONTRACT, b'score') context_db = Mock(spec=ContextDatabase) context_db.get = get self._observer = Mock(spec=DatabaseObserver) self._icon_score_database = IconScoreDatabase(score_address, context_db) self._icon_score_database.set_observer(self._observer)
def test_to_dict_camel(self): context = ContextContainer._get_context() address = Address.from_data(AddressPrefix.EOA, os.urandom(20)) age = 10 data = b'0123456789abc' self._mock_score.MixedEvent(b'i_data', address, age, data, 'text') self.assertEqual(len(context.event_logs), 1) event_log = context.event_logs[0] camel_dict = event_log.to_dict(to_camel_case) self.assertIn('scoreAddress', camel_dict) self.assertIn('indexed', camel_dict) self.assertIn('data', camel_dict) self.assertEqual(3, len(camel_dict['indexed'])) self.assertEqual(3, len(camel_dict['data']))
def setUp(self): address = Address.from_data(AddressPrefix.CONTRACT, b'address') db = Mock(spec=IconScoreDatabase) db.attach_mock(address, 'address') context = IconScoreContext() traces = Mock(spec=list) step_counter = Mock(spec=IconScoreStepCounter) context.type = IconScoreContextType.INVOKE context.func_type = IconScoreFuncType.WRITABLE context.tx_batch = TransactionBatch() context.event_logs = [] context.traces = traces context.step_counter = step_counter context.get_owner = Mock() context.internal_call.icx_engine = Mock(spec=IcxEngine) ContextContainer._push_context(context) self._mock_score = EventlogScore(db)
def setUp(self): state_db_root_path = 'state_db' self.state_db_root_path = state_db_root_path rmtree(state_db_root_path) os.mkdir(state_db_root_path) address = Address.from_data(AddressPrefix.CONTRACT, b'score') context = IconScoreContext(IconScoreContextType.INVOKE) context.block_batch = BlockBatch() context.tx_batch = TransactionBatch() db_path = os.path.join(state_db_root_path, 'db') context_db = ContextDatabase.from_path(db_path, True) meta_context_db = MetaContextDatabase(context_db.key_value_db) self.context_db = context_db self.meta_context_db = meta_context_db self.address = address self.context = context
def setUp(self): state_db_root_path = 'state_db' self.state_db_root_path = state_db_root_path rmtree(state_db_root_path) os.mkdir(state_db_root_path) address = Address.from_data(AddressPrefix.CONTRACT, b'score') context_factory = IconScoreContextFactory(max_size=2) context = context_factory.create(IconScoreContextType.INVOKE) context.block_batch = BlockBatch() context.tx_batch = TransactionBatch() db_path = os.path.join(state_db_root_path, 'db') context_db = ContextDatabase.from_path(db_path, True) self.context_factory = context_factory self.context_db = context_db self.address = address self.context = context
def test_call_event(self): context = ContextContainer._get_context() name = "name" address = Address.from_data(AddressPrefix.EOA, os.urandom(20)) age = 10 phone_number = "000" # Tests simple event emit self._mock_score.ZeroIndexEvent(name, address, age) self.assertEqual(len(context.event_logs), 1) event_log = context.event_logs[0] self.assertEqual(1, len(event_log.indexed)) self.assertEqual(3, len(event_log.data)) # This event has a indexed parameter, # so the list of indexed Should have 2 items self._mock_score.OneIndexEvent(name, address, age) self.assertEqual(len(context.event_logs), 2) event_log = context.event_logs[1] self.assertEqual(2, len(event_log.indexed)) self.assertEqual(2, len(event_log.data)) logs_bloom = IconServiceEngine._generate_logs_bloom(context.event_logs) # Asserts whether the SCORE address is included in the bloom self.assert_score_address_in_bloom(logs_bloom) zero_event_bloom_data = \ int(0).to_bytes(1, DATA_BYTE_ORDER) + \ 'ZeroIndexEvent(str,Address,int)'.encode('utf-8') self.assertIn(zero_event_bloom_data, logs_bloom) one_event_bloom_data = \ int(0).to_bytes(1, DATA_BYTE_ORDER) + \ 'OneIndexEvent(str,Address,int)'.encode('utf-8') self.assertIn(one_event_bloom_data, logs_bloom) name_bloom_data = int(1).to_bytes( 1, DATA_BYTE_ORDER) + name.encode('utf-8') self.assertIn(name_bloom_data, logs_bloom)