packages.valory.skills.abstract`_`round`_`abci.tests.test`_`behaviours

Test the behaviours.py module of the skill.

test`_`skill`_`public`_`id

def test_skill_public_id() -> None

Test skill module public ID

RoundA Objects

class RoundA(AbstractRound)

Round A.

end`_`block

def end_block() -> Optional[Tuple[BaseSynchronizedData, EventType]]

End block.

check`_`payload

def check_payload(payload: BaseTxPayload) -> None

Check payload.

process`_`payload

def process_payload(payload: BaseTxPayload) -> None

Process payload.

RoundB Objects

class RoundB(AbstractRound)

Round B.

end`_`block

def end_block() -> Optional[Tuple[BaseSynchronizedData, EventType]]

End block.

check`_`payload

def check_payload(payload: BaseTxPayload) -> None

Check payload.

process`_`payload

def process_payload(payload: BaseTxPayload) -> None

Process payload.

ConcreteBackgroundRound Objects

class ConcreteBackgroundRound(AbstractRound)

Concrete Background Round.

end`_`block

def end_block() -> Optional[Tuple[BaseSynchronizedData, EventType]]

End block.

check`_`payload

def check_payload(payload: BaseTxPayload) -> None

Check payload.

process`_`payload

def process_payload(payload: BaseTxPayload) -> None

Process payload.

BehaviourA Objects

class BehaviourA(BaseBehaviour)

Dummy behaviour.

``init``

def __init__(*args: Any, **kwargs: Any) -> None

Initialize behaviour.

setup

def setup() -> None

Setup behaviour.

async`_`act

def async_act() -> Generator

Dummy act method.

BehaviourB Objects

class BehaviourB(BaseBehaviour)

Dummy behaviour.

async`_`act

def async_act() -> Generator

Dummy act method.

BehaviourC Objects

class BehaviourC(BaseBehaviour, ABC)

Dummy behaviour.

test`_`auto`_`behaviour`_`id

def test_auto_behaviour_id() -> None

Test that the 'auto_behaviour_id()' method works as expected.

ConcreteBackgroundBehaviour Objects

class ConcreteBackgroundBehaviour(BaseBehaviour)

Dummy behaviour.

async`_`act

def async_act() -> Generator

Dummy act method.

ConcreteAbciApp Objects

class ConcreteAbciApp(AbciApp)

Concrete ABCI App.

ConcreteRoundBehaviour Objects

class ConcreteRoundBehaviour(AbstractRoundBehaviour)

Concrete round behaviour.

behaviours

type: ignore

background`_`behaviours`_`cls

type: ignore

TestAbstractRoundBehaviour Objects

class TestAbstractRoundBehaviour()

Test 'AbstractRoundBehaviour' class.

setup`_`method

def setup_method() -> None

Set up the tests.

test`_`setup

@pytest.mark.parametrize("use_termination", (True, False))
def test_setup(use_termination: bool) -> None

Test 'setup' method.

test`_`setup`_`pending`_`offences`_`included`_`when`_`slashing`_`enabled

def test_setup_pending_offences_included_when_slashing_enabled() -> None

Test that PendingOffencesBehaviour is included when use_slashing=True.

test`_`teardown

def test_teardown() -> None

Test 'teardown' method.

test`_`current`_`behaviour`_`return`_`none

def test_current_behaviour_return_none() -> None

Test 'current_behaviour' property return None.

test`_`act`_`current`_`behaviour`_`name`_`is`_`none

def test_act_current_behaviour_name_is_none() -> None

Test 'act' with current behaviour None.

test`_`check`_`matching`_`round`_`consistency`_`no`_`behaviour

@pytest.mark.parametrize(
    "no_round, error",
    (
        (
            True,
            "Behaviour 'behaviour_without_round' specifies unknown 'unknown' as a matching round. "
            "Please make sure that the round is implemented and belongs to the FSM. "
            "If 'behaviour_without_round' is a background behaviour, please make sure that it is set correctly, "
            "by overriding the corresponding attribute of the chained skill's behaviour.",
        ),
        (False, "round round_1 is not a matching round of any behaviour"),
    ),
)
def test_check_matching_round_consistency_no_behaviour(no_round: bool,
                                                       error: str) -> None

Test classmethod '_check_matching_round_consistency', when no behaviour or round is specified.

test`_`check`_`matching`_`round`_`consistency

def test_check_matching_round_consistency() -> None

Test classmethod '_check_matching_round_consistency', negative case.

test`_`check`_`matching`_`round`_`consistency`_`with`_`bg`_`rounds

@pytest.mark.parametrize("behaviour_cls", (set(), {MagicMock()}))
def test_check_matching_round_consistency_with_bg_rounds(
        behaviour_cls: set) -> None

Test classmethod '_check_matching_round_consistency' when a background behaviour class is set.

test`_`get`_`behaviour`_`id`_`to`_`behaviour`_`mapping`_`negative

def test_get_behaviour_id_to_behaviour_mapping_negative() -> None

Test classmethod '_get_behaviour_id_to_behaviour_mapping', negative case.

test`_`get`_`round`_`to`_`behaviour`_`mapping`_`two`_`behaviours`_`same`_`round

def test_get_round_to_behaviour_mapping_two_behaviours_same_round() -> None

Test classmethod '_get_round_to_behaviour_mapping' when two different behaviours point to the same round.

test`_`get`_`round`_`to`_`behaviour`_`mapping`_`with`_`final`_`rounds

def test_get_round_to_behaviour_mapping_with_final_rounds() -> None

Test classmethod '_get_round_to_behaviour_mapping' with final rounds.

test`_`check`_`behaviour`_`id`_`uniqueness`_`negative

def test_check_behaviour_id_uniqueness_negative() -> None

Test metaclass method '_check_consistency', negative case.

test`_`check`_`consistency`_`two`_`behaviours`_`same`_`round

def test_check_consistency_two_behaviours_same_round() -> None

Test metaclass method '_check_consistency' when two different behaviours point to the same round.

test`_`check`_`initial`_`behaviour`_`in`_`set`_`of`_`behaviours`_`negative`_`case

def test_check_initial_behaviour_in_set_of_behaviours_negative_case() -> None

Test classmethod '_check_initial_behaviour_in_set_of_behaviours' when initial behaviour is NOT in the set.

test`_`act`_`no`_`round`_`change

def test_act_no_round_change() -> None

Test the 'act' method of the behaviour, with no round change.

test`_`act`_`behaviour`_`setup

def test_act_behaviour_setup() -> None

Test the 'act' method of the FSM behaviour triggers setup() of the behaviour.

test`_`act`_`with`_`round`_`change

def test_act_with_round_change() -> None

Test the 'act' method of the behaviour, with round change.

test`_`act`_`with`_`round`_`change`_`after`_`current`_`behaviour`_`is`_`none

def test_act_with_round_change_after_current_behaviour_is_none() -> None

Test the 'act' method of the behaviour, with round change, after cur behaviour is none.

test`_`termination`_`behaviour`_`acting

@mock.patch.object(
    AbstractRoundBehaviour,
    "_process_current_round",
)
@mock.patch.object(
    TmManager,
    "tm_communication_unhealthy",
    new_callable=mock.PropertyMock,
    return_value=False,
)
@mock.patch.object(
    TmManager,
    "is_acting",
    new_callable=mock.PropertyMock,
    return_value=False,
)
@pytest.mark.parametrize("expected_termination_acting", (True, False))
def test_termination_behaviour_acting(
        _: mock._patch, __: mock._patch, ___: mock._patch,
        expected_termination_acting: bool) -> None

Test if the termination background behaviour is acting only when it should.

test`_`try`_`fix`_`call

@mock.patch.object(
    AbstractRoundBehaviour,
    "_process_current_round",
)
@pytest.mark.parametrize(
    ("mock_tm_communication_unhealthy", "mock_is_acting", "expected_fix"),
    [
        (True, True, True),
        (False, True, True),
        (True, False, True),
        (False, False, False),
    ],
)
def test_try_fix_call(_: mock._patch, mock_tm_communication_unhealthy: bool,
                      mock_is_acting: bool, expected_fix: bool) -> None

Test that try_fix is called when necessary.

test`_`meta`_`round`_`behaviour`_`when`_`instance`_`not`_`subclass`_`of`_`abstract`_`round`_`behaviour

def test_meta_round_behaviour_when_instance_not_subclass_of_abstract_round_behaviour(
) -> (None)

Test instantiation of meta class when instance not a subclass of abstract round behaviour.

test`_`abstract`_`round`_`behaviour`_`instantiation`_`without`_`attributes`_`raises`_`error

def test_abstract_round_behaviour_instantiation_without_attributes_raises_error(
) -> (None)

Test that definition of concrete subclass of AbstractRoundBehavior without attributes raises error.

test`_`abstract`_`round`_`behaviour`_`matching`_`rounds`_`not`_`covered

def test_abstract_round_behaviour_matching_rounds_not_covered() -> None

Test that definition of concrete subclass of AbstractRoundBehavior when matching round not covered.

test`_`self`_`loops`_`in`_`abci`_`app`_`reinstantiate`_`behaviour

@mock.patch.object(
    BaseBehaviour,
    "tm_communication_unhealthy",
    new_callable=mock.PropertyMock,
    return_value=False,
)
def test_self_loops_in_abci_app_reinstantiate_behaviour(
        _: mock._patch) -> None

Test that a self-loop transition in the AbciApp will trigger a transition in the round behaviour.

LongRunningBehaviour Objects

class LongRunningBehaviour(BaseBehaviour)

A behaviour that runs forevever.

async`_`act

def async_act() -> Generator

An act method that simply cycles forever.

test`_`reset`_`should`_`be`_`performed`_`when`_`tm`_`unhealthy

def test_reset_should_be_performed_when_tm_unhealthy() -> None

Test that hard reset is performed while a behaviour is running, and tendermint communication is unhealthy.

TestPendingOffencesBehaviour Objects

class TestPendingOffencesBehaviour()

Tests for PendingOffencesBehaviour.

setup`_`class

@classmethod
def setup_class(cls) -> None

Setup the test class.

test`_`pending`_`offences`_`act

@pytest.mark.skipif(
    platform.system() == "Windows",
    reason="`timegm` behaves differently on Windows. "
    "As a result, the generation of `last_transition_timestamp` is invalid.",
)
@given(
    offence=st.builds(
        PendingOffense,
        accused_agent_address=st.text(),
        round_count=st.integers(min_value=0),
        offense_type=st.sampled_from(OffenseType),
        last_transition_timestamp=st.floats(
            min_value=timegm(datetime(1971, 1, 1).utctimetuple()),
            max_value=timegm(datetime(8000, 1, 1).utctimetuple()) - 2000,
        ),
        time_to_live=st.floats(min_value=1, max_value=2000),
    ),
    wait_ticks=st.integers(min_value=0, max_value=1000),
    expired=st.booleans(),
)
def test_pending_offences_act(offence: PendingOffense, wait_ticks: int,
                              expired: bool) -> None

Test PendingOffencesBehaviour.

packages.valory.skills.abstract_round_abci.tests.test_behaviours

test_skill_public_id

RoundA Objects

end_block

check_payload

process_payload

RoundB Objects

end_block

check_payload

process_payload

ConcreteBackgroundRound Objects

end_block

check_payload

process_payload

BehaviourA Objects

__init__

setup

async_act

BehaviourB Objects

async_act

BehaviourC Objects

test_auto_behaviour_id

ConcreteBackgroundBehaviour Objects

async_act

ConcreteAbciApp Objects

ConcreteRoundBehaviour Objects

behaviours

background_behaviours_cls

TestAbstractRoundBehaviour Objects

setup_method

test_setup

test_setup_pending_offences_included_when_slashing_enabled

test_teardown

test_current_behaviour_return_none

test_act_current_behaviour_name_is_none

test_check_matching_round_consistency_no_behaviour

test_check_matching_round_consistency

test_check_matching_round_consistency_with_bg_rounds

test_get_behaviour_id_to_behaviour_mapping_negative

test_get_round_to_behaviour_mapping_two_behaviours_same_round

test_get_round_to_behaviour_mapping_with_final_rounds

test_check_behaviour_id_uniqueness_negative

test_check_consistency_two_behaviours_same_round

test_check_initial_behaviour_in_set_of_behaviours_negative_case

test_act_no_round_change

test_act_behaviour_setup

test_act_with_round_change

test_act_with_round_change_after_current_behaviour_is_none

test_termination_behaviour_acting

test_try_fix_call

test_meta_round_behaviour_when_instance_not_subclass_of_abstract_round_behaviour

test_abstract_round_behaviour_instantiation_without_attributes_raises_error

test_abstract_round_behaviour_matching_rounds_not_covered

test_self_loops_in_abci_app_reinstantiate_behaviour

LongRunningBehaviour Objects

async_act

test_reset_should_be_performed_when_tm_unhealthy

TestPendingOffencesBehaviour Objects

setup_class

test_pending_offences_act

packages.valory.skills.abstract`_`round`_`abci.tests.test`_`behaviours

test`_`skill`_`public`_`id

end`_`block

check`_`payload

process`_`payload

end`_`block

check`_`payload

process`_`payload

end`_`block

check`_`payload

process`_`payload

``init``

async`_`act

async`_`act

test`_`auto`_`behaviour`_`id

async`_`act

background`_`behaviours`_`cls

setup`_`method

test`_`setup

test`_`setup`_`pending`_`offences`_`included`_`when`_`slashing`_`enabled

test`_`teardown

test`_`current`_`behaviour`_`return`_`none

test`_`act`_`current`_`behaviour`_`name`_`is`_`none

test`_`check`_`matching`_`round`_`consistency`_`no`_`behaviour

test`_`check`_`matching`_`round`_`consistency

test`_`check`_`matching`_`round`_`consistency`_`with`_`bg`_`rounds

test`_`get`_`behaviour`_`id`_`to`_`behaviour`_`mapping`_`negative

test`_`get`_`round`_`to`_`behaviour`_`mapping`_`two`_`behaviours`_`same`_`round

test`_`get`_`round`_`to`_`behaviour`_`mapping`_`with`_`final`_`rounds

test`_`check`_`behaviour`_`id`_`uniqueness`_`negative

test`_`check`_`consistency`_`two`_`behaviours`_`same`_`round

test`_`check`_`initial`_`behaviour`_`in`_`set`_`of`_`behaviours`_`negative`_`case

test`_`act`_`no`_`round`_`change

test`_`act`_`behaviour`_`setup

test`_`act`_`with`_`round`_`change

test`_`act`_`with`_`round`_`change`_`after`_`current`_`behaviour`_`is`_`none

test`_`termination`_`behaviour`_`acting

test`_`try`_`fix`_`call

test`_`meta`_`round`_`behaviour`_`when`_`instance`_`not`_`subclass`_`of`_`abstract`_`round`_`behaviour

test`_`abstract`_`round`_`behaviour`_`instantiation`_`without`_`attributes`_`raises`_`error

test`_`abstract`_`round`_`behaviour`_`matching`_`rounds`_`not`_`covered

test`_`self`_`loops`_`in`_`abci`_`app`_`reinstantiate`_`behaviour

async`_`act

test`_`reset`_`should`_`be`_`performed`_`when`_`tm`_`unhealthy

setup`_`class

test`_`pending`_`offences`_`act