def test_handle_get_prep_term_with_electable_preps(self): block_height = 100 params = {} term = self.term context = Mock() context.block.height = block_height engine = PRepEngine() engine.term = term engine.preps = self.preps ret: dict = engine.handle_get_prep_term(context) assert ret["blockHeight"] == block_height assert ret["sequence"] == term.sequence assert ret["startBlockHeight"] == term.start_block_height assert ret["endBlockHeight"] == term.end_block_height assert ret["totalSupply"] == term.total_supply assert ret["totalDelegated"] == term.total_delegated assert ret["irep"] == term.irep # Main P-Reps: 22, Sub P-Reps: 78 prep_list: List[Dict[str, Union[int, str, 'Address']]] = ret["preps"] assert len(prep_list) == PREP_MAIN_AND_SUB_PREPS for i, prep_snapshot in enumerate(term.preps): prep_item: Dict[str, Union[int, str, 'Address']] = prep_list[i] assert prep_item["address"] == prep_snapshot.address
def test__reset_block_validation_penalty(self): engine = PRepEngine() engine.term = self.term engine.preps = self.preps self.term.freeze() self.preps.freeze() assert engine.term.is_frozen() assert engine.preps.is_frozen() IconScoreContext.engine = Mock() IconScoreContext.storage = Mock() IconScoreContext.engine.prep = engine context = _create_context() assert engine.preps.size(active_prep_only=False) == context.preps.size( active_prep_only=False) for i in range(engine.preps.size(active_prep_only=True)): assert engine.preps.get_by_index(i) == context._preps.get_by_index( i) # Impose block validation penalty on 5 Main P-Reps indices = set() for _ in range(5): index = random.randint(0, self.main_prep_count - 1) indices.add(index) # Impose the block validation penalty on randomly chosen 5 or less than P-Reps for i in indices: prep = context.preps.get_by_index(i) dirty_prep = context.get_prep(prep.address, mutable=True) assert not dirty_prep.is_frozen() dirty_prep.penalty = PenaltyReason.BLOCK_VALIDATION dirty_prep.grade = PRepGrade.CANDIDATE context.put_dirty_prep(dirty_prep) context.update_dirty_prep_batch() for i in indices: prep = context.preps.get_by_index(i) assert prep.is_frozen() assert prep.status == PRepStatus.ACTIVE assert prep.penalty == PenaltyReason.BLOCK_VALIDATION assert prep.grade == PRepGrade.CANDIDATE engine._reset_block_validation_penalty(context) # The penalties of P-Reps in context should be reset # to PenaltyReason.NONE at the last block of the current term for prep in context.preps: assert prep.status == PRepStatus.ACTIVE assert prep.penalty == PenaltyReason.NONE for i in indices: prep = context.preps.get_by_index(i) assert prep.status == PRepStatus.ACTIVE assert prep.penalty == PenaltyReason.NONE
def test_handle_get_inactive_preps(self): expected_block_height = 1234 context = Mock() context.block.height = expected_block_height old_term = self.term old_preps = self.preps new_term = old_term.copy() new_preps = old_preps.copy(mutable=True) expected_preps = [] expected_total_delegated = 0 cases = ( (PRepStatus.UNREGISTERED, PenaltyReason.NONE), (PRepStatus.UNREGISTERED, PenaltyReason.BLOCK_VALIDATION), (PRepStatus.DISQUALIFIED, PenaltyReason.PREP_DISQUALIFICATION), (PRepStatus.DISQUALIFIED, PenaltyReason.LOW_PRODUCTIVITY), (PRepStatus.ACTIVE, PenaltyReason.BLOCK_VALIDATION), (PRepStatus.ACTIVE, PenaltyReason.NONE) ) s_data = random.sample([i for i in range(len(new_term.main_preps))], len(cases)) for index, case in enumerate(cases): prep = new_preps.get_by_index(s_data[index]) dirty_prep = prep.copy() dirty_prep.status = case[0] dirty_prep.penalty = case[1] new_preps.replace(dirty_prep) assert new_preps.is_dirty() assert old_preps.get_by_address(prep.address) == prep assert new_preps.get_by_address(prep.address) != prep assert new_preps.get_by_address(prep.address) == dirty_prep new_term.update_invalid_elected_preps([dirty_prep]) if dirty_prep.status != PRepStatus.ACTIVE: expected_preps.append(dirty_prep) expected_total_delegated += dirty_prep.delegated expected_preps = sorted(expected_preps, key=lambda node: node.order()) engine = PRepEngine() engine.term = new_term engine.preps = new_preps response: dict = engine.handle_get_inactive_preps(context) inactive_preps: list = response["preps"] for i, prep in enumerate(expected_preps): expected_prep_data: dict = prep.to_dict(PRepDictType.FULL) assert expected_prep_data == inactive_preps[i] assert len(expected_preps) == len(inactive_preps) assert expected_block_height == response["blockHeight"] assert expected_total_delegated == response["totalDelegated"]
def test_handle_get_prep_term_with_penalized_preps(self): block_height = 200 sequence = 78 period = 43120 start_block_height = 200 end_block_height = 200 + period - 1 irep = icx_to_loop(40000) total_supply = icx_to_loop(800_460_000) total_delegated = icx_to_loop(1000) params = {} context = Mock() context.block.height = block_height main_prep_count = 22 elected_prep_count = 100 total_prep_count = 106 term = Term(sequence=sequence, start_block_height=start_block_height, period=period, irep=irep, total_supply=total_supply, total_delegated=total_delegated) preps = PRepContainer() for i in range(total_prep_count): address = Address.from_prefix_and_int(AddressPrefix.EOA, i) delegated = icx_to_loop(1000 - i) penalty = PenaltyReason.NONE status = PRepStatus.ACTIVE if 0 <= i <= 4: # block validation penalty preps: 5 penalty: 'PenaltyReason' = PenaltyReason.BLOCK_VALIDATION elif i == 5: # unregistered preps: 1 status = PRepStatus.UNREGISTERED elif 6 <= i <= 7: # low productivity preps: 2 status = PRepStatus.DISQUALIFIED penalty = PenaltyReason.LOW_PRODUCTIVITY elif 8 <= i <= 10: # disqualified preps: 3 status = PRepStatus.DISQUALIFIED penalty = PenaltyReason.PREP_DISQUALIFICATION prep = PRep(address, block_height=i, delegated=delegated, penalty=penalty, status=status) prep.freeze() preps.add(prep) preps.freeze() assert preps.size(active_prep_only=False) == total_prep_count electable_preps = filter(lambda x: x.is_electable(), preps) term.set_preps(electable_preps, main_prep_count=main_prep_count, elected_prep_count=elected_prep_count) engine = PRepEngine() engine.term = term engine.preps = preps ret: dict = engine.handle_get_prep_term(context) assert ret["blockHeight"] == block_height assert ret["sequence"] == sequence assert ret["startBlockHeight"] == start_block_height assert ret["endBlockHeight"] == end_block_height assert ret["totalSupply"] == total_supply assert ret["totalDelegated"] == total_delegated assert ret["irep"] == irep prep_list: List[Dict[str, Union[int, str, 'Address']]] = ret["preps"] assert len(prep_list) == elected_prep_count for i, prep_snapshot in enumerate(term.preps): prep_item: Dict[str, Union[int, str, 'Address']] = prep_list[i] assert prep_item["address"] == prep_snapshot.address assert prep_item["status"] == PRepStatus.ACTIVE.value assert prep_item["penalty"] == PenaltyReason.NONE.value # The P-Reps which got penalized for consecutive 660 block validation failure # are located at the end of the P-Rep list prev_delegated = -1 for i, prep_item in enumerate(prep_list[-5:]): assert prep_item["address"] == Address.from_prefix_and_int(AddressPrefix.EOA, i) assert prep_item["status"] == PRepStatus.ACTIVE.value assert prep_item["penalty"] == PenaltyReason.BLOCK_VALIDATION.value delegated: int = prep_item["delegated"] if prev_delegated >= 0: assert prev_delegated >= delegated prev_delegated = delegated