def test_getReturn(self):
amount = 1000
self.score.get_purchase_return = Mock()
self.score.get_sale_return = Mock()
self.score.get_cross_connector_return = Mock()
from_token = Address.from_string("cx" + os.urandom(20).hex())
to_token = Address.from_string("cx" + os.urandom(20).hex())
with patch.object(IconScoreBase, 'msg', Message(self.owner)):
self.score.getReturn(from_token, to_token, amount)
self.score.get_cross_connector_return.assert_called_with(
from_token, to_token, amount)
from_token = self.token
to_token = Address.from_string("cx" + os.urandom(20).hex())
with patch.object(IconScoreBase, 'msg', Message(self.owner)):
self.score.getReturn(from_token, to_token, amount)
self.score.get_sale_return.assert_called_with(to_token, amount)
from_token = Address.from_string("cx" + os.urandom(20).hex())
to_token = self.token
with patch.object(IconScoreBase, 'msg', Message(self.owner)):
self.score.getReturn(from_token, to_token, amount)
self.score.get_purchase_return.assert_called_with(
from_token, amount)
def test_withdrawTokens(self):
to = Address.from_string("hx" + os.urandom(20).hex())
amount = 100
self.score._is_active.return_value = True
self.score._connectors[self.initial_connector_token].is_set.set(False)
with patch_property(IconScoreBase, 'msg', Message(self.owner)):
self.score.withdrawTokens(self.initial_connector_token, to, amount)
self.score._is_active.assert_called()
FlexibleTokenController.withdrawTokens.assert_called_with(
self.initial_connector_token, to, amount)
self.score._is_active.reset_mock()
self.score._is_active.return_value = False
self.score._connectors[self.initial_connector_token].is_set.set(True)
with patch_property(IconScoreBase, 'msg', Message(self.owner)):
self.score.withdrawTokens(self.initial_connector_token, to, amount)
self.score._is_active.assert_called()
FlexibleTokenController.withdrawTokens.assert_called_with(
self.initial_connector_token, to, amount)
self.score._is_active.reset_mock()
self.score._is_active.return_value = False
self.score._connectors[self.initial_connector_token].is_set.set(False)
with patch_property(IconScoreBase, 'msg', Message(self.owner)):
self.score.withdrawTokens(self.initial_connector_token, to, amount)
self.score._is_active.assert_called()
FlexibleTokenController.withdrawTokens.assert_called_with(
self.initial_connector_token, to, amount)
def test_getCrossConnectorReturn(self):
connector_token2 = Address.from_string("cx" + os.urandom(20).hex())
connector_token2_weight = 500000
self.score.addConnector(connector_token2, connector_token2_weight,
False)
amount = 1000
self.score.getConnectorBalance = Mock(return_value=10000)
with MultiPatch([
patch_property(IconScoreBase, 'msg', Message(self.owner)),
patch.object(FixedMapFormula,
'calculate_cross_connector_return',
return_value=1000)
]):
result = self.score.get_cross_connector_return(
self.initial_connector_token, connector_token2, amount)
self.assertEqual(1000, result['amount'])
self.assertEqual(0, result['fee'])
# sets the fee to 1%
self.score._max_conversion_fee.set(1000000)
self.score._conversion_fee.set(10000)
with MultiPatch([
patch_property(IconScoreBase, 'msg', Message(self.owner)),
patch.object(FixedMapFormula,
'calculate_cross_connector_return',
return_value=1000)
]):
result = self.score.get_cross_connector_return(
self.initial_connector_token, connector_token2, amount)
self.assertEqual(980, result['amount'])
self.assertEqual(20, result['fee'])
def test_registerAddress(self):
eoa_address = Address.from_string("hx" + "3" * 40)
network_id = self.registry_score.NETWORK
network_address = Address.from_string("cx" + "2" * 40)
with patch_property(IconScoreBase, 'msg',
Message(self.registry_owner)):
# failure case: invalid register score address
self.assertRaises(RevertException,
self.registry_score.registerAddress, network_id,
ZERO_SCORE_ADDRESS)
# failure case: try to register eoa address
self.assertRaises(RevertException,
self.registry_score.registerAddress, network_id,
eoa_address)
# failure case: score name is not in the SCORE_KEYS
non_listed_id = "NON_LISTED_SCORE_ID"
self.assertRaises(RevertException,
self.registry_score.registerAddress,
non_listed_id, network_address)
# success case: register network
self.registry_score.registerAddress(network_id, network_address)
self.assertEqual(network_address,
self.registry_score._score_address[network_id])
self.registry_score.AddressUpdate.assert_called_with(
network_id, network_address)
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_install_result(self):
IconScoreContext.engine.deploy.invoke = Mock()
from_ = Address(AddressPrefix.EOA, os.urandom(20))
to_ = Address(AddressPrefix.EOA, os.urandom(20))
self._mock_context.tx = Transaction(os.urandom(32), 0, from_, to_, 0)
self._mock_context.msg = Message(from_)
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(0, 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 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 setUp(self):
self.patcher = ScorePatcher(Converter)
self.patcher.start()
self.score_address = Address.from_string("cx" + os.urandom(20).hex())
self.score = Converter(create_db(self.score_address))
self.owner = Address.from_string("hx" + os.urandom(20).hex())
self.token = Address.from_string("cx" + os.urandom(20).hex())
registry = Address.from_string("cx" + os.urandom(20).hex())
max_conversion_fee = 1000000
self.initial_connector_token = Address.from_string(
"cx" + os.urandom(20).hex())
self.initial_connector_weight = 500000
with patch_property(IconScoreBase, 'msg', Message(self.owner)):
self.score.on_install(self.token, registry, max_conversion_fee,
self.initial_connector_token,
self.initial_connector_weight)
FlexibleTokenController.on_install.assert_called_with(
self.score, self.token)
self.score._token.set(self.token)
self.assertEqual(registry, self.score._registry.get())
self.assertEqual(registry, self.score._prev_registry.get())
self.assertEqual(max_conversion_fee,
self.score._max_conversion_fee.get())
self.assertEqual(
True, self.score._connectors[
self.initial_connector_token].is_set.get())
self.assertEqual(
self.initial_connector_weight, self.score._connectors[
self.initial_connector_token].weight.get())
def test_tokenFallback_cross_convert_called(self):
# Mocks parent functions
self.score.getOwner.return_value = self.owner
self.score._is_active.return_value = True
self.score._convert_cross_connector = Mock()
network_address = Address.from_string("cx" + os.urandom(20).hex())
to_token = Address.from_string("cx" + os.urandom(20).hex())
to_token_weight = 500000
self.score.addConnector(to_token, to_token_weight, False)
min_return = 10
data = {'toToken': str(to_token), 'minReturn': min_return}
# success case
token = self.initial_connector_token
value = 100
with MultiPatch([
patch_property(IconScoreBase, 'msg', Message(token)),
patch.object(InternalCall,
'other_external_call',
return_value=network_address)
]):
self.score.tokenFallback(network_address, value,
json_dumps(data).encode())
assert_inter_call(self, self.score.address,
self.score._registry.get(), 'getAddress',
[ScoreRegistry.NETWORK])
self.score._convert_cross_connector.assert_called_with(
network_address, token, to_token, value, min_return)
def test_tokenFallback_convert_called_wrong_params(self):
# Mocks parent functions
self.score.getOwner.return_value = self.owner
self.score._is_active.return_value = True
self.score._convert = Mock()
network_address = Address.from_string("cx" + os.urandom(20).hex())
to_token = Address.from_string("cx" + os.urandom(20).hex())
# missing param `minReturn`
data = {
'toToken': str(to_token),
}
token = self.initial_connector_token
value = 100
with MultiPatch([
patch_property(IconScoreBase, 'msg', Message(token)),
patch.object(InternalCall,
'other_external_call',
return_value=network_address)
]):
self.assertRaises(RevertException, self.score.tokenFallback,
network_address, value,
json_dumps(data).encode())
self.score._convert.assert_not_called()
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_convert_by_path(self):
# success case: check all other SCORE's methods called correctly
# in this path, 'flexible token' is 1, 3, 'from token' is 0, 2, 'to token' is 2, 4 ( index )
converted_path = [
self.connector_token_list[0], self.flexible_token_address_list[0],
self.connector_token_list[1], self.flexible_token_address_list[1],
self.connector_token_list[2]
]
for_address = Address.from_string("hx" + "a" * 40)
# this method substitutes 'create_interface_score' method of IconScoreBase
def create_interface_score_mock(token_address, interface_score):
if interface_score.__name__ == 'ProxyScore(ABCFlexibleToken)':
# add getOwner method to the token address instance
# this token instance operates as a converter interface score
token_address.getOwner = Mock(
return_value="{0} converter address".format(token_address))
else:
# add 'transfer' and 'balanceOf' methods to token address
# this token instance operates as an IRC token interface score
token_address.transfer = PropertyMock()
token_address.balanceOf = PropertyMock(return_value=0)
return token_address
with patch_property(IconScoreBase, 'msg', Message(self.network_owner)):
# the amount is set to 0. in this unit test, do not check the exact return value
# just check whether if specific methods have been called or not
amount = 0
min_return = 10
self.network_score.create_interface_score = create_interface_score_mock
actual_to_token, actual_amount = self.network_score.\
_convert_by_path(converted_path, amount, min_return, for_address)
self.assertEqual(converted_path[-1], actual_to_token)
self.assertEqual(amount, actual_amount)
# check flexible token's 'getOwner' method have been called ( flexible token's index is 1, 3 )
for i, flexible_token in enumerate(converted_path):
if i % 2 == 1:
flexible_token.getOwner.assert_called_once()
# check 'from' token's 'transfer' method have been called ( from token's index is 0, 2 )
for i, from_token in enumerate(converted_path):
if i % 2 == 0 and i != len(converted_path) - 1:
data = dict()
data["toToken"] = str(converted_path[i + 2])
# in the last converting, minReturn should be user inputted data (10)
data["minReturn"] = min_return if i == len(
converted_path) - 3 else 1
encoded_data = json_dumps(data).encode()
from_token.transfer.assert_called_once_with(
"{0} converter address".format(converted_path[i + 1]),
amount, encoded_data)
# check 'to' token's getBalanceOf method have been called ( to token's index is 2, 4 )
for i, from_token in enumerate(converted_path):
if i % 2 == 0 and i != 0:
# 'balanceOf' method should be called twice
from_token.balanceOf.assert_called()
def test_isActive(self):
with MultiPatch([
patch_property(IconScoreBase, 'msg', Message(self.owner)),
patch.object(InternalCall, 'other_external_call'),
]) as mocks:
mocks[1].return_value = self.score.address
is_active = self.score.isActive()
self.assertEqual(True, is_active)
with MultiPatch([
patch_property(IconScoreBase, 'msg', Message(self.owner)),
patch.object(InternalCall, 'other_external_call'),
]) as mocks:
mocks[1].return_value = ZERO_SCORE_ADDRESS
is_active = self.score.isActive()
self.assertEqual(False, is_active)
def test_withdrawTokens_failure(self):
to = Address.from_string("hx" + os.urandom(20).hex())
amount = 100
self.score._is_active.return_value = True
self.score._connectors[self.initial_connector_token].is_set.set(True)
with patch_property(IconScoreBase, 'msg', Message(self.owner)):
self.assertRaises(RevertException, self.score.withdrawTokens,
self.initial_connector_token, to, amount)
self.score._is_active.assert_called()
def test_disableRegistryUpdate(self):
self.score.require_owner_or_manager_only.reset_mock()
with patch_property(IconScoreBase, 'msg', Message(self.owner)):
self.score.disableRegistryUpdate(True)
self.score.require_owner_or_manager_only.assert_called()
self.assertEqual(False, self.score._allow_registry_update.get())
self.score.disableRegistryUpdate(False)
self.assertEqual(True, self.score._allow_registry_update.get())
def setUp(self):
self.patcher = ScorePatcher(TokenHolder)
self.patcher.start()
self.score_address = Address.from_string("cx" + "1" * 40)
self.token_holder = TokenHolder(create_db(self.score_address))
self.token_owner = Address.from_string("hx" + "2" * 40)
with patch_property(IconScoreBase, 'msg', Message(self.token_owner)):
self.token_holder.on_install()
Owned.on_install.assert_called_with(self.token_holder)
def test_restoreRegistry(self):
self.score.require_owner_or_manager_only.reset_mock()
prev_registry = self.score._prev_registry.get()
with patch_property(IconScoreBase, 'msg', Message(self.owner)):
self.score.restoreRegistry()
self.score.require_owner_or_manager_only.assert_called()
self.assertEqual(prev_registry, self.score._prev_registry.get())
self.assertEqual(prev_registry, self.score._registry.get())
def test_transferOwnerShip(self):
# failure case: non owner try to transfer ownership.
non_owner = Address.from_string("hx" + "3" * 40)
new_owner = Address.from_string("hx" + "4" * 40)
with patch_property(IconScoreBase, 'msg', Message(non_owner)):
self.assertRaises(RevertException, self.score.transferOwnerShip,
new_owner)
# failure case: set new owner as previous owner
with patch_property(IconScoreBase, 'msg', Message(self.sender)):
self.assertRaises(RevertException, self.score.transferOwnerShip,
self.sender)
# success case: transfer ownership to new_owner
with patch_property(IconScoreBase, 'msg', Message(self.sender)):
self.score.require_owner_only = Mock()
self.score.transferOwnerShip(new_owner)
self.score.require_owner_only.assert_called()
self.assertEqual(self.sender, self.score._owner.get())
self.assertEqual(new_owner, self.score._new_owner.get())
def setUp(self):
self.patcher = ScorePatcher(Owned)
self.patcher.start()
score_address = Address.from_string("cx" + "1" * 40)
self.score = Owned(create_db(score_address))
self.sender = Address.from_string("hx" + "2" * 40)
with patch_property(IconScoreBase, 'msg', Message(self.sender)):
self.score.on_install()
self.assertEqual(self.sender, self.score._owner.get())
self.assertEqual(ZERO_SCORE_ADDRESS, self.score._new_owner.get())
def setUp(self):
self.key_value_mock = MockKeyValueDatabase({})
self.db = IconScoreDatabase(self.sender,
ContextDatabase(self.key_value_mock))
IconScoreBase.get_owner = lambda score_object, score_address: self.sender
self.smart_wallet = SmartWallet(self.db)
type(self.smart_wallet).msg = PropertyMock(
return_value=Message(sender=self.sender, value=10000))
# print test name
print(f"===== {self._testMethodName} ==========================")
def test_withdrawTokens(self):
token_address = Address.from_string("cx" + "2" * 40)
token_receiver = Address.from_string("hx" + "3" * 40)
irc_token_score_interface = \
self.token_holder.create_interface_score(token_address, ProxyScore(ABCIRCToken))
irc_token_score_interface.transfer = Mock()
with MultiPatch([
patch_property(IconScoreBase, 'msg',
Message(self.token_owner)),
patch.object(TokenHolder,
'create_interface_score',
return_value=irc_token_score_interface)
]):
amount = 10
# success case: withdraw 10 token
self.token_holder.withdrawTokens(token_address, token_receiver,
amount)
self.token_holder.create_interface_score.assert_called_with(
token_address, ProxyScore(ABCIRCToken))
irc_token_score_interface.transfer.assert_called_with(
token_receiver, amount)
self.token_holder.create_interface_score.reset_mock()
irc_token_score_interface.transfer.reset_mock()
# failure case: amount is under 0
invalid_amount = -1
self.assertRaises(RevertException,
self.token_holder.withdrawTokens, token_address,
token_receiver, invalid_amount)
self.token_holder.create_interface_score.assert_not_called()
irc_token_score_interface.transfer.assert_not_called()
self.token_holder.create_interface_score.reset_mock()
irc_token_score_interface.transfer.reset_mock()
# failure case: 'to' address is this
self.assertRaises(RevertException,
self.token_holder.withdrawTokens, token_address,
self.score_address, amount)
self.token_holder.create_interface_score.assert_not_called()
irc_token_score_interface.transfer.assert_not_called()
self.token_holder.create_interface_score.reset_mock()
irc_token_score_interface.transfer.reset_mock()
# failure case: 'to' address is invalid address
self.assertRaises(RevertException,
self.token_holder.withdrawTokens, token_address,
ZERO_SCORE_ADDRESS, amount)
self.token_holder.create_interface_score.assert_not_called()
irc_token_score_interface.transfer.assert_not_called()
self.token_holder.create_interface_score.reset_mock()
irc_token_score_interface.transfer.reset_mock()
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 setUp(self):
self.patcher = ScorePatcher(IcxToken)
self.patcher.start()
self.score_address = Address.from_string("cx" + "1" * 40)
self.icx_token = IcxToken(create_db(self.score_address))
self.token_owner = Address.from_string("hx" + "2" * 40)
with patch_property(IconScoreBase, 'msg', Message(self.token_owner)):
self.icx_token.on_install()
IRCToken.on_install.assert_called_with(self.icx_token, 'icx_token',
'ICX', 0, 18)
TokenHolder.on_install.assert_called_with(self.icx_token)
def get_default_context():
context = IconScoreContext()
block = Block()
context.block = block
context.icon_score_mapper = score_mapper
context.traces = []
context.validate_score_blacklist = Mock(return_value=True)
context.tx = Transaction()
context.msg = Message()
context.get_icon_score = get_icon_score
context.block_batch = None
context.tx_batch = None
return context
def test_transfer(self):
# failure case: transfer token to this score (should raise error)
with patch_property(IconScoreBase, 'msg', Message(self.token_owner)):
self.assertRaises(RevertException, self.icx_token.transfer,
self.score_address, 10)
IRCToken.transfer.assert_not_called()
# success case: send 10 token to other
token_receiver = Address.from_string("hx" + "4" * 40)
self.icx_token.transfer(token_receiver, 10)
IRCToken.transfer.assert_called_with(self.icx_token, token_receiver,
10, None)
def test_disableConversions(self):
self.score.require_owner_or_manager_only.reset_mock()
self.score._conversions_enabled.set(True)
with patch_property(IconScoreBase, 'msg', Message(self.owner)):
self.score.disableConversions(True)
self.score.require_owner_or_manager_only.assert_called()
self.score.ConversionsEnable.assert_called_with(False)
self.assertEqual(False, self.score._conversions_enabled.get())
self.score.disableConversions(False)
self.assertEqual(True, self.score._conversions_enabled.get())
def test_setConversionFee(self):
self.score.require_owner_or_manager_only.reset_mock()
old_conversion_fee = self.score._conversion_fee.get()
conversion_fee = 10000
with patch_property(IconScoreBase, 'msg', Message(self.owner)):
self.score.setConversionFee(conversion_fee)
self.score.require_owner_or_manager_only.assert_called()
self.score.ConversionFeeUpdate.assert_called_with(
old_conversion_fee, conversion_fee)
self.assertEqual(self.score._conversion_fee.get(), conversion_fee)
def setUp(self):
self.patcher = ScorePatcher(IRCToken)
self.patcher.start()
self.score_address = Address.from_string("cx" + "1" * 40)
self.irc_token = IRCToken(create_db(self.score_address))
token_name = "test_token"
token_symbol = "TST"
token_supply = 100
token_decimals = 18
self.token_owner = Address.from_string("hx" + "2" * 40)
# failure case: total supply is under 0
with patch_property(IconScoreBase, 'msg', Message(self.token_owner)):
invalid_token_supply = -1
self.assertRaises(RevertException, self.irc_token.on_install,
token_name, token_symbol, invalid_token_supply,
token_decimals)
# failure case: decimal is under 0
with patch_property(IconScoreBase, 'msg', Message(self.token_owner)):
invalid_token_decimals = -1
self.assertRaises(RevertException, self.irc_token.on_install,
token_name, token_symbol, token_supply,
invalid_token_decimals)
# success case: deploy IRCToken with valid parameters
with patch_property(IconScoreBase, 'msg', Message(self.token_owner)):
self.irc_token.on_install(token_name, token_symbol, token_supply,
token_decimals)
self.assertEqual(token_name, self.irc_token._name.get())
self.assertEqual(token_symbol, self.irc_token._symbol.get())
self.assertEqual(token_decimals, self.irc_token._decimals.get())
self.assertEqual(token_supply * 10**token_decimals,
self.irc_token._total_supply.get())
self.assertEqual(token_supply * 10**token_decimals,
self.irc_token._balances[self.token_owner])
def test_external_transfer(self):
token_receiver = Address.from_string("hx" + "3" * 40)
with MultiPatch([
patch_property(IconScoreBase, 'msg',
Message(self.token_owner)),
patch.object(IRCToken, '_transfer')
]):
self.irc_token.transfer(token_receiver, 10)
IRCToken._transfer.assert_called_with(self.token_owner,
token_receiver, 10, b'None')
self.irc_token.transfer(token_receiver, 10, b'test')
IRCToken._transfer.assert_called_with(self.token_owner,
token_receiver, 10, b'test')
def make_context(self):
self._tx_index += 1
self._context = self._factory.create(IconScoreContextType.DIRECT)
self._context.msg = Message(self.from_address, 0)
tx_hash = create_tx_hash()
self._context.new_icon_score_mapper = IconScoreMapper()
self._context.tx = Transaction(tx_hash, origin=self.from_address)
self._context.block = Block(1, create_block_hash(), 0, None)
self._context.icon_score_mapper = self._icon_score_mapper
self._context.icx = IcxEngine()
self._context.icx.open(self._icx_storage)
ContextContainer._push_context(self._context)
self._context.validate_deployer = Mock()
self._context.validate_score_blacklist = Mock()