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_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_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 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_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_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_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 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 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 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 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 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 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_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 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 test_acceptOwnership(self):
# ### initial setting for test start
new_owner = Address.from_string("hx" + "4" * 40)
with patch_property(IconScoreBase, 'msg', Message(self.sender)):
self.score.transferOwnerShip(new_owner)
# ### initial setting for test end
# failure case: current owner try to accept ownership ( only new owner can accept ownership)
with patch_property(IconScoreBase, 'msg', Message(self.sender)):
self.assertRaises(RevertException, self.score.acceptOwnerShip)
# failure case: another address try to accept ownership
# ( only new owner can accept ownership)
another_owner = Address.from_string("hx" + "5" * 40)
with patch_property(IconScoreBase, 'msg', Message(another_owner)):
self.assertRaises(RevertException, self.score.acceptOwnerShip)
# success case: new owner accept ownership
with patch_property(IconScoreBase, 'msg', Message(new_owner)):
self.score.acceptOwnerShip()
self.assertEqual(new_owner, self.score._owner.get())
self.assertEqual(ZERO_SCORE_ADDRESS, self.score._new_owner.get())
self.score.OwnerUpdate.assert_called_with(self.sender, new_owner)
def test_getSaleReturn(self):
amount = 1000
self.score.getConnectorBalance = Mock(return_value=10000)
with MultiPatch([
patch_property(IconScoreBase, 'msg', Message(self.owner)),
patch.object(InternalCall,
'other_external_call',
return_value=10000),
patch.object(FixedMapFormula,
'calculate_sale_return',
return_value=1000)
]):
result = self.score.get_sale_return(self.initial_connector_token,
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(InternalCall,
'other_external_call',
return_value=10000),
patch.object(FixedMapFormula,
'calculate_sale_return',
return_value=1000)
]):
result = self.score.get_sale_return(self.initial_connector_token,
amount)
self.assertEqual(990, result['amount'])
self.assertEqual(10, result['fee'])
def test_acceptTokenOwnership(self):
with MultiPatch([
patch_property(IconScoreBase, 'msg', Message(self.owner)),
patch.object(InternalCall, 'other_external_call'),
]):
self.score.acceptTokenOwnership()
self.score.require_owner_only.assert_called()
assert_inter_call(
self,
self.score.address,
self.score._token.get(),
'acceptOwnerShip',
[]
)
def test_disableConnectorPurchases(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.disableConnectorPurchases(self.initial_connector_token,
True)
self.score.require_owner_only.assert_called()
connector_token = self.score._connectors[
self.initial_connector_token]
self.assertEqual(False, connector_token.is_purchase_enabled.get())
self.score.disableConnectorPurchases(self.initial_connector_token,
False)
self.assertEqual(True, connector_token.is_purchase_enabled.get())
def setUp(self):
self.patcher = ScorePatcher(IcxToken)
self.patcher.start()
self.score_address = Address.from_string("cx" + "1" * 40)
self.flexible_token_address = Address.from_string("cx" + "2" * 40)
self.score = FlexibleTokenController(create_db(self.score_address))
self.owner = Address.from_string("hx" + "2" * 40)
with MultiPatch([
patch_property(IconScoreBase, 'msg', Message(self.owner)),
patch('contracts.utility.flexible_token_controller.require_valid_address')
]) as mocks:
self.score.on_install(self.flexible_token_address)
TokenHolder.on_install.assert_called_with(self.score)
mocks[1].assert_called()
def test_transferTokenOwnership(self):
new_owner = Address.from_string("hx" + "3" * 40)
with MultiPatch([
patch_property(IconScoreBase, 'msg', Message(self.owner)),
patch.object(InternalCall, 'other_external_call'),
]):
self.score.transferTokenOwnership(new_owner)
self.score.require_owner_only.assert_called()
assert_inter_call(
self,
self.score.address,
self.score._token.get(),
'transferOwnerShip',
[new_owner])
def test_disableTokenTransfers(self):
disable = True
with MultiPatch([
patch_property(IconScoreBase, 'msg', Message(self.owner)),
patch.object(InternalCall, 'other_external_call'),
]):
self.score.disableTokenTransfers(disable)
self.score.require_owner_only.assert_called()
assert_inter_call(
self,
self.score.address,
self.score._token.get(),
'disableTransfer',
[disable]
)
def test_getConnectorBalance(self):
balance = 100
with MultiPatch([
patch_property(IconScoreBase, 'msg', Message(self.owner)),
patch.object(InternalCall,
'other_external_call',
return_value=balance)
]):
result_balance = self.score.getConnectorBalance(
self.initial_connector_token)
assert_inter_call(self, self.score.address,
self.initial_connector_token, 'balanceOf',
[self.score.address])
self.assertEqual(result_balance, balance)
def setUp(self):
self.patcher = ScorePatcher(ScoreRegistry)
self.patcher.start()
self.score_address = Address.from_string("cx" + "1" * 40)
self.registry_score = ScoreRegistry(create_db(self.score_address))
self.registry_owner = Address.from_string("hx" + "1" * 40)
with patch_property(IconScoreBase, 'msg',
Message(self.registry_owner)):
self.registry_score.on_install()
Owned.on_install.assert_called_with(self.registry_score)
# success case: when deploy ScoreRegistry, score registry address should be registered by default
self.assertEqual \
(self.score_address,
self.registry_score._score_address[self.registry_score.SCORE_REGISTRY.encode()])
