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()])