Esempio n. 1
0
    def test_normalize(self, context, mocker, revision, unstakes_info,
                       current_block_height, flag, expected_balance):
        unstakes_info = copy.deepcopy(unstakes_info)
        mocker.patch.object(IconScoreContext, "revision",
                            PropertyMock(return_value=revision))
        stake, balance = 100, 100

        coin_part = CoinPart(CoinPartType.GENERAL, flag, balance)
        stake_part = StakePart(stake=stake,
                               unstake=0,
                               unstake_block_height=0,
                               unstakes_info=unstakes_info)
        account = Account(ADDRESS,
                          current_block_height,
                          revision,
                          coin_part=coin_part,
                          stake_part=stake_part)

        if unstakes_info is None:
            remaining_unstakes = []
        else:
            remaining_unstakes = [
                unstake_info for unstake_info in unstakes_info
                if unstake_info[1] >= current_block_height
            ]

        account.normalize(revision)

        assert account.stake == stake
        assert account.balance == expected_balance
        assert account.unstakes_info == remaining_unstakes
Esempio n. 2
0
    def test_account_for_stake(self):
        address: 'Address' = create_address()
        context: 'IconScoreContext' = IconScoreContext()

        coin_part: 'CoinPart' = CoinPart()
        stake_part: 'StakePart' = StakePart()
        account = Account(address,
                          0,
                          Revision.IISS.value,
                          coin_part=coin_part,
                          stake_part=stake_part)

        balance = 1000
        account.deposit(balance)

        stake1 = 500
        unstake_block_height = 0
        remain_balance = balance - stake1

        account.set_stake(context, stake1, 0)

        self.assertEqual(stake1, account.stake)
        self.assertEqual(0, account.unstake)
        self.assertEqual(unstake_block_height, account.unstake_block_height)
        self.assertEqual(remain_balance, account.balance)

        stake2 = 100
        block_height = 10
        unstake = stake1 - stake2
        remain_balance = balance - stake1
        account.set_stake(context, stake2, block_height)

        self.assertEqual(stake2, account.stake)
        self.assertEqual(unstake, account.unstake)
        self.assertEqual(block_height, account.unstake_block_height)
        self.assertEqual(remain_balance, account.balance)

        remain_balance = remain_balance + unstake
        account._current_block_height += 11
        account.normalize(Revision.IISS.value)
        self.assertEqual(remain_balance, account.balance)