def setup(cls): """Setup the test class.""" super().setup() cls.fipa_handler = cast(GenericFipaHandler, cls._skill.skill_context.handlers.fipa) cls.strategy = cast(GenericStrategy, cls._skill.skill_context.strategy) cls.fipa_dialogues = cast(FipaDialogues, cls._skill.skill_context.fipa_dialogues) cls.list_of_messages = ( DialogueMessage(FipaMessage.Performative.CFP, {"query": "some_query"}, True), DialogueMessage(FipaMessage.Performative.PROPOSE, {"proposal": "some_proposal"}), DialogueMessage(FipaMessage.Performative.ACCEPT), DialogueMessage( FipaMessage.Performative.MATCH_ACCEPT_W_INFORM, {"info": { "address": "some_term_sender_address" }}, ), DialogueMessage( FipaMessage.Performative.INFORM, { "info": { "transaction_digest": "some_transaction_digest_body" } }, ), )
def setup(cls): """Setup the test class.""" super().setup() cls.transaction_behaviour = cast( GenericTransactionBehaviour, cls._skill.skill_context.behaviours.transaction ) cls.strategy = cast(GenericStrategy, cls._skill.skill_context.strategy) cls.logger = cls._skill.skill_context.logger cls.fipa_dialogues = cast( FipaDialogues, cls._skill.skill_context.fipa_dialogues ) cls.ledger_api_dialogues = cast( LedgerApiDialogues, cls._skill.skill_context.ledger_api_dialogues ) cls.list_of_messages = ( DialogueMessage(FipaMessage.Performative.CFP, {"query": "some_query"}), DialogueMessage( FipaMessage.Performative.PROPOSE, {"proposal": "some_proposal"} ), DialogueMessage(FipaMessage.Performative.ACCEPT), DialogueMessage( FipaMessage.Performative.MATCH_ACCEPT_W_INFORM, {"info": {"address": "some_term_sender_address"}}, ), )
def setup(cls): """Setup the test class.""" super().setup() cls.signing_handler = cast(SigningHandler, cls._skill.skill_context.handlers.signing) cls.ledger_api_dialogues = cast( LedgerApiDialogues, cls._skill.skill_context.ledger_api_dialogues) cls.signing_dialogues = cast( SigningDialogues, cls._skill.skill_context.signing_dialogues) cls.logger = cls.signing_handler.context.logger cls.terms = Terms( "some_ledger_id", cls._skill.skill_context.agent_address, "counterprty", {"currency_id": 50}, {"good_id": -10}, "some_nonce", ) cls.list_of_signing_messages = (DialogueMessage( SigningMessage.Performative.SIGN_TRANSACTION, { "terms": cls.terms, "raw_transaction": SigningMessage.RawTransaction("some_ledger_id", {"some_key": "some_value"}), }, ), )
def setup(cls): """Setup the test class.""" super().setup() cls.contract_api_handler = cast( ContractApiHandler, cls._skill.skill_context.handlers.contract_api) cls.contract_api_dialogues = cast( ContractApiDialogues, cls._skill.skill_context.contract_api_dialogues) cls.signing_dialogues = cast( SigningDialogues, cls._skill.skill_context.signing_dialogues) cls.logger = cls.contract_api_handler.context.logger cls.ledger_id = "some_ledger_id" cls.contract_id = "some_contract_id" cls.callable = "some_callable" cls.kwargs = Kwargs({"some_key": "some_value"}) cls.list_of_contract_api_messages = (DialogueMessage( ContractApiMessage.Performative.GET_DEPLOY_TRANSACTION, { "ledger_id": cls.ledger_id, "contract_id": cls.contract_id, "callable": cls.callable, "kwargs": cls.kwargs, }, ), )
def _setup_fipa_ledger_api_dialogues( self_, ) -> Tuple[LedgerApiDialogue, FipaDialogue]: """Setup fipa and ledger_api dialogues for some of the following tests.""" fipa_dialogue = cast( FipaDialogue, self_.prepare_skill_dialogue( dialogues=self_.fipa_dialogues, messages=self_.list_of_messages, ), ) fipa_dialogue.terms = "terms" # type: ignore ledger_api_dialogue = cast( LedgerApiDialogue, self_.prepare_skill_dialogue( dialogues=self_.ledger_api_dialogues, messages=( DialogueMessage( LedgerApiMessage.Performative.GET_BALANCE, {"ledger_id": "some_ledger_id", "address": "some_address"}, ), ), ), ) ledger_api_dialogue.associated_fipa_dialogue = fipa_dialogue return ledger_api_dialogue, fipa_dialogue
def test_cancel_tac_empty_dialogue(self): """Test the _cancel_tac method of the tac behaviour where the dialogue is empty.""" # setup self.game._phase = Phase.GAME_REGISTRATION mocked_now_time = self._time("00:05") datetime_mock = Mock(wraps=datetime.datetime) datetime_mock.now.return_value = mocked_now_time self.parameters._min_nb_agents = 2 self.game._registration.register_agent(COUNTERPARTY_ADDRESS, self.agent_1_name) dialogue = self.prepare_skill_dialogue( self.tac_dialogues, (DialogueMessage( TacMessage.Performative.REGISTER, {"agent_name": "some_agent_name"}, True, ), ), ) dialogue._incoming_messages = [] # operation with patch("datetime.datetime", new=datetime_mock): with patch.object( self.game, "get_unregister_tac_description", return_value=self.mocked_description, ): with patch.object(self.tac_behaviour.context.logger, "log"): with pytest.raises( ValueError, match="Error when retrieving last message."): self.tac_behaviour.act()
def setup(cls): """Setup the test class.""" super().setup() cls.oef_search_handler = cast( OefSearchHandler, cls._skill.skill_context.handlers.oef_search) cls.strategy = cast(Strategy, cls._skill.skill_context.strategy) cls.logger = cls._skill.skill_context.logger cls.oef_search_dialogues = cast( OefSearchDialogues, cls._skill.skill_context.oef_search_dialogues) cls.data = b"some_body" cls.query = Query( [ Constraint("some_attribute", ConstraintType("==", "some_service")) ], DataModel( "some_name", [ Attribute("some_attribute", str, False, "Some attribute descriptions.") ], ), ) cls.mocked_description = Description({"foo1": 1, "bar1": 2}) cls.list_of_messages = (DialogueMessage( OefSearchMessage.Performative.SEARCH_SERVICES, {"query": cls.query}), )
def test_extract_message_fields(self): """Test the _extract_message_fields method.""" expected_performative = FipaMessage.Performative.ACCEPT expected_contents = {} expected_is_incoming = False expected_target = 4 dialogue_message = DialogueMessage( expected_performative, expected_contents, expected_is_incoming, expected_target, ) ( actual_performative, actual_contents, actual_message_id, actual_is_incoming, actual_target, ) = self._extract_message_fields(message=dialogue_message, index=3, last_is_incoming=True) assert actual_message_id == 4 assert actual_target == expected_target assert actual_performative == expected_performative assert actual_contents == expected_contents assert actual_is_incoming == expected_is_incoming
def setup(cls): """Setup the test class.""" super().setup() cls.http_handler = cast(HttpHandler, cls._skill.skill_context.handlers.http_handler) cls.logger = cls._skill.skill_context.logger cls.strategy = cast(Strategy, cls._skill.skill_context.strategy) cls.http_dialogues = cast(HttpDialogues, cls._skill.skill_context.http_dialogues) cls.method = "some_method" cls.url = "some_url" cls.version = "some_version" cls.headers = "some_headers" cls.body = b"some_body" cls.list_of_http_messages = (DialogueMessage( HttpMessage.Performative.REQUEST, { "method": cls.method, "url": cls.url, "version": cls.version, "headers": cls.headers, "body": cls.body, }, ), ) cls.confirmed_aea = b"ConfirmedAEA" cls.developer_handle = b"DeveloperHandle"
def test_provide_unspecified_fields(self): """Test the _provide_unspecified_fields method.""" dialogue_message_unspecified = DialogueMessage( FipaMessage.Performative.ACCEPT, {}) is_incoming, target = self._provide_unspecified_fields( dialogue_message_unspecified, last_is_incoming=False) assert is_incoming is True assert target is None dialogue_message_specified = DialogueMessage( FipaMessage.Performative.ACCEPT, {}, False, 4) is_incoming, target = self._provide_unspecified_fields( dialogue_message_specified, last_is_incoming=True) assert is_incoming is False assert target == 4
def setup(cls): """Setup the test class.""" super().setup() cls.tac_handler = cast(TacHandler, cls._skill.skill_context.handlers.tac) cls.tac_dialogues = cast(TacDialogues, cls._skill.skill_context.tac_dialogues) cls.game = cast(Game, cls._skill.skill_context.game) cls.parameters = cast(Parameters, cls._skill.skill_context.parameters) cls.agent_name = "some_agent_name" cls.list_of_messages = ( DialogueMessage(TacMessage.Performative.REGISTER, {"agent_name": cls.agent_name}, True), DialogueMessage( TacMessage.Performative.GAME_DATA, { "amount_by_currency_id": { "FET": 1 }, "exchange_params_by_currency_id": { "FET": 1.0 }, "quantities_by_good_id": { "G1": 10 }, "utility_params_by_good_id": { "G1": 1.0 }, "fee_by_currency_id": { "FET": 1 }, "agent_addr_to_name": { COUNTERPARTY_ADDRESS: "some_name" }, "currency_id_to_name": { "FET": "FETCH" }, "good_id_to_name": { "G1": "Good_1" }, "version_id": "v1", }, ), )
def test_negative_prepare_skill_dialogue_invalid_opponent_initiated(self): """Negative test for prepare_skill_dialogue method with an invalid dialogue initiated by the opponent.""" fipa_dialogues = FipaDialogues( self_address=self.skill.skill_context.agent_address) dialogue_messages = ( DialogueMessage(FipaMessage.Performative.PROPOSE, {"proposal": "some_proposal"}, True), DialogueMessage( FipaMessage.Performative.PROPOSE, {"proposal": "some_counter_proposal_1"}, ), DialogueMessage( FipaMessage.Performative.PROPOSE, {"proposal": "some_counter_proposal_2"}, ), DialogueMessage( FipaMessage.Performative.PROPOSE, {"proposal": "some_counter_proposal_3"}, ), DialogueMessage( FipaMessage.Performative.PROPOSE, {"proposal": "some_counter_proposal_4"}, ), DialogueMessage(FipaMessage.Performative.ACCEPT, {}), DialogueMessage(FipaMessage.Performative.MATCH_ACCEPT_W_INFORM, {"info": "some_info"}), ) with pytest.raises( AEAEnforceError, match="Cannot update the dialogue with message number 1"): self.prepare_skill_dialogue( fipa_dialogues, dialogue_messages, "counterparty", )
def setup(cls): """Setup the test class.""" super().setup() cls.oef_search_handler = cast(OefSearchHandler, cls._skill.skill_context.handlers.oef) cls.oef_dialogues = cast(OefSearchDialogues, cls._skill.skill_context.oef_search_dialogues) cls.list_of_messages = (DialogueMessage( OefSearchMessage.Performative.SEARCH_SERVICES, {"query": "some_query"}), )
def setup(cls): """Setup the test class.""" super().setup() cls.ledger_api_handler = cast( GenericLedgerApiHandler, cls._skill.skill_context.handlers.ledger_api) cls.strategy = cast(GenericStrategy, cls._skill.skill_context.strategy) cls.fipa_dialogues = cast(FipaDialogues, cls._skill.skill_context.fipa_dialogues) cls.ledger_api_dialogues = cast( LedgerApiDialogues, cls._skill.skill_context.ledger_api_dialogues) cls.terms = Terms( "some_ledger_id", cls._skill.skill_context.agent_address, "counterprty", {"currency_id": 50}, {"good_id": -10}, "some_nonce", ) cls.list_of_fipa_messages = ( DialogueMessage(FipaMessage.Performative.CFP, {"query": "some_query"}, True), DialogueMessage(FipaMessage.Performative.PROPOSE, {"proposal": "some_proposal"}), DialogueMessage(FipaMessage.Performative.ACCEPT), DialogueMessage( FipaMessage.Performative.MATCH_ACCEPT_W_INFORM, {"info": { "address": "some_term_sender_address" }}, ), DialogueMessage( FipaMessage.Performative.INFORM, { "info": { "transaction_digest": "some_transaction_digest_body" } }, ), ) cls.transaction_digest = TransactionDigest("some_ledger_id", "some_body") cls.transaction_receipt = TransactionReceipt("some_ledger_id", "some_receipt", "some_transaction") cls.list_of_ledger_api_messages = ( DialogueMessage( LedgerApiMessage.Performative.GET_TRANSACTION_RECEIPT, {"transaction_digest": cls.transaction_digest}, ), DialogueMessage( LedgerApiMessage.Performative.TRANSACTION_RECEIPT, {"transaction_receipt": cls.transaction_receipt}, ), )
def test_negative_prepare_skill_dialogue_invalid(self): """Negative test for prepare_skill_dialogue method with an invalid dialogue (a message has invalid target).""" fipa_dialogues = FipaDialogues( self_address=self.skill.skill_context.agent_address) dialogue_messages = ( DialogueMessage(FipaMessage.Performative.CFP, {"query": "some_query"}), DialogueMessage( FipaMessage.Performative.PROPOSE, {"proposal": "some_proposal"}, target=2, ), ) with pytest.raises( AEAEnforceError, match="Cannot update the dialogue with message number .*"): self.prepare_skill_dialogue( fipa_dialogues, dialogue_messages, "counterparty", )
def setup(cls): """Setup the test class.""" super().setup() cls.default_handler = cast( DefaultHandler, cls._skill.skill_context.handlers.default_handler) cls.logger = cls._skill.skill_context.logger cls.strategy = cast(Strategy, cls._skill.skill_context.strategy) cls.default_dialogues = cast( DefaultDialogues, cls._skill.skill_context.default_dialogues) cls.list_of_default_messages = (DialogueMessage( DefaultMessage.Performative.BYTES, {"content": b"some_content"}), ) cls.confirmed_aea = b"ConfirmedAEA" cls.developer_handle = b"DeveloperHandle"
def test_prepare_skill_dialogue_valid_opponent_initiated(self): """Positive test for prepare_skill_dialogue method with a valid dialogue initiated by the opponent.""" fipa_dialogues = FipaDialogues( self_address=self.skill.skill_context.agent_address) dialogue_messages = ( DialogueMessage(FipaMessage.Performative.CFP, {"query": "some_query"}, True), DialogueMessage(FipaMessage.Performative.PROPOSE, {"proposal": "some_proposal"}), DialogueMessage( FipaMessage.Performative.PROPOSE, {"proposal": "some_counter_proposal_1"}, ), DialogueMessage( FipaMessage.Performative.PROPOSE, {"proposal": "some_counter_proposal_2"}, ), DialogueMessage( FipaMessage.Performative.PROPOSE, {"proposal": "some_counter_proposal_3"}, ), DialogueMessage( FipaMessage.Performative.PROPOSE, {"proposal": "some_counter_proposal_4"}, ), DialogueMessage(FipaMessage.Performative.ACCEPT, {}), DialogueMessage(FipaMessage.Performative.MATCH_ACCEPT_W_INFORM, {"info": "some_info"}), ) dialogue = self.prepare_skill_dialogue( fipa_dialogues, dialogue_messages, "counterparty", ) assert type(dialogue) == FipaDialogue assert not dialogue.is_self_initiated assert len(dialogue._outgoing_messages) == 4 assert len(dialogue._incoming_messages) == 4 assert dialogue._outgoing_messages[ 1].proposal == "some_counter_proposal_2" assert dialogue._outgoing_messages[-1].info == "some_info"
def setup(cls, **kwargs): """Setup the test class.""" super().setup(**kwargs) cls.http_handler = cast(HttpHandler, cls._skill.skill_context.handlers.http) cls.logger = cls._skill.skill_context.logger cls.http_dialogues = cast(HttpDialogues, cls._skill.skill_context.http_dialogues) cls.list_of_messages = (DialogueMessage( HttpMessage.Performative.REQUEST, { "method": "get", "url": "some_url", "headers": "", "version": "", "body": b"", }, ), )
def setup(cls, **kwargs): """Setup the test class.""" super().setup() cls.prometheus_handler = cast( PrometheusHandler, cls._skill.skill_context.handlers.prometheus) cls.logger = cls._skill.skill_context.logger cls.strategy = cast(Strategy, cls._skill.skill_context.strategy) cls.prometheus_dialogues = cast( PrometheusDialogues, cls._skill.skill_context.prometheus_dialogues) cls.list_of_messages = (DialogueMessage( PrometheusMessage.Performative.ADD_METRIC, { "type": "Gauge", "title": "some_title", "description": "some_description", "labels": {}, }, ), )
def setup(cls): """Setup the test class.""" super().setup() cls.transaction_behaviour = cast( TransactionBehaviour, cls._skill.skill_context.behaviours.transaction ) cls.strategy = cast(Strategy, cls._skill.skill_context.strategy) cls.logger = cls._skill.skill_context.logger cls.register_dialogues = cast( RegisterDialogues, cls._skill.skill_context.register_dialogues ) cls.ledger_api_dialogues = cast( LedgerApiDialogues, cls._skill.skill_context.ledger_api_dialogues ) cls.list_of_registration_messages = ( DialogueMessage( RegisterMessage.Performative.REGISTER, {"info": {"some_key": "some_value"}}, ), )
def setup(cls): """Setup the test class.""" super().setup() cls.contract_api_handler = cast( ContractApiHandler, cls._skill.skill_context.handlers.contract_api) cls.strategy = cast(Strategy, cls._skill.skill_context.strategy) cls.logger = cls.contract_api_handler.context.logger cls.contract_api_dialogues = cast( ContractApiDialogues, cls._skill.skill_context.contract_api_dialogues) cls.contract_id = "some_contract_id" cls.contract_address = "some_contract_address," cls.callable = "some_callable" cls.kwargs = Kwargs({"some_key": "some_value"}) cls.state = State("some_ledger_id", {"some_key": "some_value"}) cls.terms = Terms( ledger_id="some_ledger_id", sender_address="some_sender_address", counterparty_address="some_counterparty", amount_by_currency_id={"1": -10}, quantities_by_good_id={}, is_sender_payable_tx_fee=True, nonce="some_none", fee_by_currency_id={"1": 100}, ) cls.list_of_contract_api_messages = (DialogueMessage( ContractApiMessage.Performative.GET_DEPLOY_TRANSACTION, { "ledger_id": LEDGER_ID, "contract_id": cls.contract_id, "callable": cls.callable, "kwargs": cls.kwargs, }, ), ) cls.info = {"ethereum_address": "some_ethereum_address"}
def test_handle_balance(self): """Test the _handle_balance method of the ledger_api handler.""" # setup ledger_id = "some_Ledger_id" ledger_api_dialogue = cast( LedgerApiDialogue, self.prepare_skill_dialogue( dialogues=self.ledger_api_dialogues, messages=(DialogueMessage( LedgerApiMessage.Performative.GET_BALANCE, { "ledger_id": "some_ledger_id", "address": "some_address" }, ), ), counterparty=LEDGER_API_ADDRESS, ), ) incoming_message = cast( LedgerApiMessage, self.build_incoming_message_for_skill_dialogue( dialogue=ledger_api_dialogue, performative=LedgerApiMessage.Performative.BALANCE, ledger_id=ledger_id, balance=10, ), ) # operation with patch.object(self.ledger_api_handler.context.logger, "log") as mock_logger: self.ledger_api_handler.handle(incoming_message) # after mock_logger.assert_any_call( logging.INFO, f"starting balance on {ledger_id} ledger={incoming_message.balance}.", )
def _setup_register_ledger_api_dialogues( self_, ) -> Tuple[LedgerApiDialogue, RegisterDialogue]: """Setup register and ledger_api dialogues for some of the following tests.""" register_dialogue = cast( RegisterDialogue, self_.prepare_skill_dialogue( dialogues=self_.register_dialogues, messages=self_.list_of_registration_messages, ), ) register_dialogue.terms = Terms( ledger_id="some_ledger_id", sender_address="some_sender_address", counterparty_address="some_counterparty", amount_by_currency_id={"1": -10}, quantities_by_good_id={}, is_sender_payable_tx_fee=True, nonce="some_none", fee_by_currency_id={"1": 100}, ) ledger_api_dialogue = cast( LedgerApiDialogue, self_.prepare_skill_dialogue( dialogues=self_.ledger_api_dialogues, messages=( DialogueMessage( LedgerApiMessage.Performative.GET_BALANCE, {"ledger_id": "some_ledger_id", "address": "some_address"}, ), ), ), ) ledger_api_dialogue.associated_register_dialogue = register_dialogue return ledger_api_dialogue, register_dialogue
def test_act_ii(self): """Test the act method of the tac behaviour where phase is game_registration and start_time < now < end_time and nb_agent < min_nb_agents.""" # setup self.game._phase = Phase.GAME_REGISTRATION mocked_now_time = self._time("00:05") datetime_mock = Mock(wraps=datetime.datetime) datetime_mock.now.return_value = mocked_now_time self.parameters._min_nb_agents = 2 self.game._registration.register_agent(COUNTERPARTY_ADDRESS, self.agent_1_name) self.prepare_skill_dialogue( self.tac_dialogues, (DialogueMessage( TacMessage.Performative.REGISTER, {"agent_name": "some_agent_name"}, True, ), ), ) # operation with patch("datetime.datetime", new=datetime_mock): with patch.object( self.game, "get_unregister_tac_description", return_value=self.mocked_description, ): with patch.object(self.tac_behaviour.context.logger, "log") as mock_logger: self.tac_behaviour.act() # after self.assert_quantity_in_outbox(2) # _cancel_tac mock_logger.assert_any_call(logging.INFO, "notifying agents that TAC is cancelled.") has_attributes, error_str = self.message_has_attributes( actual_message=self.get_message_from_outbox(), message_type=TacMessage, performative=TacMessage.Performative.CANCELLED, to=COUNTERPARTY_ADDRESS, sender=self.skill.skill_context.agent_address, ) assert has_attributes, error_str # phase is POST_GAME assert self.game.phase == Phase.POST_GAME # _unregister_tac has_attributes, error_str = self.message_has_attributes( actual_message=self.get_message_from_outbox(), message_type=OefSearchMessage, performative=OefSearchMessage.Performative.UNREGISTER_SERVICE, to=self.skill.skill_context.search_service_address, sender=self.skill.skill_context.agent_address, service_description=self.mocked_description, ) assert has_attributes, error_str mock_logger.assert_any_call(logging.INFO, "unregistering TAC data model from SOEF.")
def test_act_iii(self): """Test the act method of the tac behaviour where phase is game_registration and start_time < now < end_time and nb_agent >= min_nb_agents""" # setup self.game._phase = Phase.GAME_REGISTRATION mocked_now_time = self._time("00:05") datetime_mock = Mock(wraps=datetime.datetime) datetime_mock.now.return_value = mocked_now_time self.parameters._min_nb_agents = 2 self.game._registration.register_agent(self.agent_1_address, self.agent_1_name) self.game._registration.register_agent(self.agent_2_address, self.agent_2_name) mocked_holdings_summary = "some_holdings_summary" mocked_equilibrium_summary = "some_equilibrium_summary" self.prepare_skill_dialogue( self.tac_dialogues, (DialogueMessage( TacMessage.Performative.REGISTER, {"agent_name": self.agent_1_name}, True, ), ), self.agent_1_address, ) self.prepare_skill_dialogue( self.tac_dialogues, (DialogueMessage( TacMessage.Performative.REGISTER, {"agent_name": self.agent_2_name}, True, ), ), self.agent_2_address, ) # operation with patch("datetime.datetime", new=datetime_mock): with patch.object( self.game, "get_unregister_tac_description", return_value=self.mocked_description, ): with patch.object( type(self.game), "holdings_summary", new_callable=PropertyMock, return_value=mocked_holdings_summary, ): with patch.object( type(self.game), "equilibrium_summary", new_callable=PropertyMock, return_value=mocked_equilibrium_summary, ): with patch.object(self.tac_behaviour.context.logger, "log") as mock_logger: self.tac_behaviour.act() # after self.assert_quantity_in_outbox(3) # _start_tac mock_logger.assert_any_call( logging.INFO, f"started competition:\n{mocked_holdings_summary}") mock_logger.assert_any_call( logging.INFO, f"computed equilibrium:\n{mocked_equilibrium_summary}") tac_message_1_in_outbox = cast(TacMessage, self.get_message_from_outbox()) self._assert_tac_message_and_logging_output(tac_message_1_in_outbox, self.agent_1_address, mock_logger) tac_message_2_in_outbox = cast(TacMessage, self.get_message_from_outbox()) self._assert_tac_message_and_logging_output(tac_message_2_in_outbox, self.agent_2_address, mock_logger) # phase is POST_GAME assert self.game.phase == Phase.GAME # _unregister_tac has_attributes, error_str = self.message_has_attributes( actual_message=self.get_message_from_outbox(), message_type=OefSearchMessage, performative=OefSearchMessage.Performative.UNREGISTER_SERVICE, to=self.skill.skill_context.search_service_address, sender=self.skill.skill_context.agent_address, service_description=self.mocked_description, ) assert has_attributes, error_str assert self.tac_behaviour._registered_description is None mock_logger.assert_any_call(logging.INFO, "unregistering TAC data model from SOEF.")
def test_act_iv(self): """Test the act method of the tac behaviour where phase is GAME and end_time < now.""" # setup self.game._phase = Phase.GAME mocked_now_time = self._time("00:07") datetime_mock = Mock(wraps=datetime.datetime) datetime_mock.now.return_value = mocked_now_time self.parameters._min_nb_agents = 2 self.game._registration.register_agent(self.agent_1_address, self.agent_1_name) self.game._registration.register_agent(self.agent_2_address, self.agent_2_name) mocked_holdings_summary = "some_holdings_summary" mocked_equilibrium_summary = "some_equilibrium_summary" self.prepare_skill_dialogue( self.tac_dialogues, (DialogueMessage( TacMessage.Performative.REGISTER, {"agent_name": self.agent_1_name}, True, ), ), self.agent_1_address, ) self.prepare_skill_dialogue( self.tac_dialogues, (DialogueMessage( TacMessage.Performative.REGISTER, {"agent_name": self.agent_2_name}, True, ), ), self.agent_2_address, ) # operation with patch("datetime.datetime", new=datetime_mock): with patch.object( self.game, "get_unregister_tac_description", return_value=self.mocked_description, ): with patch.object( type(self.game), "holdings_summary", new_callable=PropertyMock, return_value=mocked_holdings_summary, ): with patch.object( type(self.game), "equilibrium_summary", new_callable=PropertyMock, return_value=mocked_equilibrium_summary, ): with patch.object(self.tac_behaviour.context.logger, "log") as mock_logger: self.tac_behaviour.act() # after self.assert_quantity_in_outbox(2) # _cancel_tac mock_logger.assert_any_call(logging.INFO, "notifying agents that TAC is cancelled.") has_attributes, error_str = self.message_has_attributes( actual_message=self.get_message_from_outbox(), message_type=TacMessage, performative=TacMessage.Performative.CANCELLED, to=self.agent_1_address, sender=self.skill.skill_context.agent_address, ) assert has_attributes, error_str has_attributes, error_str = self.message_has_attributes( actual_message=self.get_message_from_outbox(), message_type=TacMessage, performative=TacMessage.Performative.CANCELLED, to=self.agent_2_address, sender=self.skill.skill_context.agent_address, ) assert has_attributes, error_str mock_logger.assert_any_call( logging.INFO, f"finished competition:\n{mocked_holdings_summary}") mock_logger.assert_any_call( logging.INFO, f"computed equilibrium:\n{mocked_equilibrium_summary}") # phase is POST_GAME assert self.game.phase == Phase.POST_GAME assert self.skill.skill_context.is_active is False
def setup(cls, **kwargs): """Setup the test class.""" super().setup(**kwargs) cls.ledger_api_handler = cast( LedgerApiHandler, cls._skill.skill_context.handlers.ledger_api) cls.logger = cls._skill.skill_context.logger cls.simple_oracle_behaviour = cast( SimpleOracleBehaviour, cls._skill.skill_context.behaviours.simple_oracle_behaviour, ) cls.ledger_api_dialogues = cast( LedgerApiDialogues, cls._skill.skill_context.ledger_api_dialogues) cls.contract_api_dialogues = cast( ContractApiDialogues, cls._skill.skill_context.contract_api_dialogues) cls.signing_dialogues = cast( SigningDialogues, cls._skill.skill_context.signing_dialogues) cls.list_of_ledger_api_messages = ( DialogueMessage( LedgerApiMessage.Performative.GET_BALANCE, { "ledger_id": LEDGER_ID, "address": "some_eth_address" }, ), DialogueMessage( LedgerApiMessage.Performative.SEND_SIGNED_TRANSACTION, { "signed_transaction": SignedTransaction( LEDGER_ID, DEFAULT_TX) }, ), DialogueMessage( LedgerApiMessage.Performative.GET_TRANSACTION_RECEIPT, { "transaction_digest": TransactionDigest(LEDGER_ID, "some_digest") }, ), DialogueMessage( LedgerApiMessage.Performative.GET_STATE, { "ledger_id": LEDGER_ID, "callable": "some_callable", "args": (), "kwargs": LedgerApiMessage.Kwargs({}), }, ), ) cls.list_of_contract_api_messages = (DialogueMessage( ContractApiMessage.Performative.GET_DEPLOY_TRANSACTION, { "ledger_id": LEDGER_ID, "contract_id": "some_contract_id", "callable": "some_callable", "kwargs": ContractApiKwargs({"some_key": "some_value"}), }, ), ) cls.list_of_signing_messages = (DialogueMessage( SigningMessage.Performative.SIGN_TRANSACTION, { "terms": Terms(*DEFAULT_TERMS), "raw_transaction": RawTransaction(LEDGER_ID, DEFAULT_TX), }, ), )
def setup(cls): """Setup the test class.""" super().setup() cls.ledger_api_handler = cast( LedgerApiHandler, cls._skill.skill_context.handlers.ledger_api) cls.ledger_api_dialogues = cast( LedgerApiDialogues, cls._skill.skill_context.ledger_api_dialogues) cls.signing_dialogues = cast( SigningDialogues, cls._skill.skill_context.signing_dialogues) cls.contract_api_dialogues = cast( ContractApiDialogues, cls._skill.skill_context.contract_api_dialogues) cls.parameters = cast(Parameters, cls._skill.skill_context.parameters) cls.game = cast(Game, cls._skill.skill_context.game) cls.logger = cls.ledger_api_handler.context.logger cls.ledger_id = "some_ledger_id" cls.contract_id = "some_contract_id" cls.callable = "some_callable" cls.kwargs = Kwargs({"some_key": "some_value"}) cls.body = {"some_key": "some_value"} cls.body_str = "some_body" cls.contract_address = "some_contract_address" cls.raw_transaction = RawTransaction(cls.ledger_id, cls.body) cls.signed_transaction = SignedTransaction(cls.ledger_id, cls.body) cls.transaction_digest = TransactionDigest(cls.ledger_id, cls.body_str) cls.receipt = {"contractAddress": cls.contract_address} cls.transaction_receipt = TransactionReceipt( cls.ledger_id, cls.receipt, {"transaction_key": "transaction_value"}) cls.terms = Terms( cls.ledger_id, cls._skill.skill_context.agent_address, "counterprty", {"currency_id": 50}, {"good_id": -10}, "some_nonce", ) cls.list_of_signing_messages = (DialogueMessage( SigningMessage.Performative.SIGN_TRANSACTION, { "terms": cls.terms, "raw_transaction": SigningMessage.RawTransaction(cls.ledger_id, cls.body), }, ), ) cls.list_of_contract_api_messages = (DialogueMessage( ContractApiMessage.Performative.GET_DEPLOY_TRANSACTION, { "ledger_id": cls.ledger_id, "contract_id": cls.contract_id, "callable": cls.callable, "kwargs": cls.kwargs, }, ), ) cls.list_of_ledger_api_messages = ( DialogueMessage(LedgerApiMessage.Performative.GET_RAW_TRANSACTION, {"terms": cls.terms}), DialogueMessage( LedgerApiMessage.Performative.RAW_TRANSACTION, {"raw_transaction": cls.raw_transaction}, ), DialogueMessage( LedgerApiMessage.Performative.SEND_SIGNED_TRANSACTION, {"signed_transaction": cls.signed_transaction}, ), DialogueMessage( LedgerApiMessage.Performative.TRANSACTION_DIGEST, {"transaction_digest": cls.transaction_digest}, ), DialogueMessage( LedgerApiMessage.Performative.GET_TRANSACTION_RECEIPT, {"transaction_digest": cls.transaction_digest}, ), )
def setup(cls): """Setup the test class.""" super().setup() cls.transaction_process_behaviour = cast( TransactionProcessBehaviour, cls._skill.skill_context.behaviours.transaction_processing, ) cls.game = cast(Game, cls._skill.skill_context.game) cls.logger = cls.transaction_process_behaviour.context.logger cls.tac_dialogues = cast(TacDialogues, cls._skill.skill_context.tac_dialogues) cls.list_of_tac_messages = ( DialogueMessage( TacMessage.Performative.REGISTER, {"agent_name": "some_agent_name"} ), DialogueMessage( TacMessage.Performative.GAME_DATA, { "amount_by_currency_id": {"FET": 1}, "exchange_params_by_currency_id": {"FET": 1.0}, "quantities_by_good_id": {"2": 10}, "utility_params_by_good_id": {"2": 1.0}, "fee_by_currency_id": {"1": 1}, "agent_addr_to_name": {COUNTERPARTY_ADDRESS: "some_agent_name"}, "currency_id_to_name": {"1": "FETCH"}, "good_id_to_name": {"2": "Good_1"}, "version_id": "v1", }, ), ) cls.tx_ids = ["tx_1", "tx_2"] cls.terms_1 = Terms( "some_ledger_id", "some_sender_address_1", "some_counterparty_address_1", {"1": 10}, {"2": 5}, "some_nonce_1", fee_by_currency_id={"1": 1}, ) cls.terms_2 = Terms( "some_ledger_id", "some_sender_address_2", "some_counterparty_address_2", {"1": 11}, {"2": 6}, "some_nonce_2", fee_by_currency_id={"1": 2}, ) cls.terms = [cls.terms_1, cls.terms_2] cls.sender_signatures = ["sender_signature_1", "sender_signature_2"] cls.counterparty_signatures = [ "counterparty_signature_1", "counterparty_signature_2", ] cls.txs = { cls.tx_ids[0]: { "terms": cls.terms[0], "sender_signature": cls.sender_signatures[0], "counterparty_signature": cls.counterparty_signatures[0], }, cls.tx_ids[1]: { "terms": cls.terms[1], "sender_signature": cls.sender_signatures[1], "counterparty_signature": cls.counterparty_signatures[1], }, }
def setup(cls): """Setup the test class.""" super().setup() cls.tac_handler = cast(TacHandler, cls._skill.skill_context.handlers.tac) cls.tac_dialogues = cast(TacDialogues, cls._skill.skill_context.tac_dialogues) cls.state_update_dialogues = cast( StateUpdateDialogues, cls._skill.skill_context.state_update_dialogues) cls.game = cast(Game, cls._skill.skill_context.game) cls.logger = cls.tac_handler.context.logger cls.agent_name = "some_agent_name" cls.amount_by_currency_id = {"1": 10} cls.exchange_params_by_currency_id = {"1": 1.0} cls.quantities_by_good_id = {"2": 10} cls.utility_params_by_good_id = {"2": 1.0} cls.fee_by_currency_id = {"1": 1} cls.agent_addr_to_name = {COUNTERPARTY_ADDRESS: "some_name"} cls.currency_id_to_name = {"1": "FETCH"} cls.good_id_to_name = {"2": "Good_1"} cls.version_id = "v1" cls.list_of_messages = ( DialogueMessage(TacMessage.Performative.REGISTER, {"agent_name": cls.agent_name}, True), DialogueMessage( TacMessage.Performative.GAME_DATA, { "amount_by_currency_id": cls.amount_by_currency_id, "exchange_params_by_currency_id": cls.exchange_params_by_currency_id, "quantities_by_good_id": cls.quantities_by_good_id, "utility_params_by_good_id": cls.utility_params_by_good_id, "fee_by_currency_id": cls.fee_by_currency_id, "agent_addr_to_name": cls.agent_addr_to_name, "currency_id_to_name": cls.currency_id_to_name, "good_id_to_name": cls.good_id_to_name, "version_id": cls.version_id, }, ), DialogueMessage( TacMessage.Performative.TRANSACTION, { "transaction_id": "some_transaction_id", "ledger_id": "some_ledger_id", "sender_address": "some_sender_address", "counterparty_address": "some_counterparty_address", "amount_by_currency_id": { "1": 5 }, "fee_by_currency_id": { "1": 1 }, "quantities_by_good_id": { "2": -5 }, "nonce": "some_nonce", "sender_signature": "some_sender_signature", "counterparty_signature": "some_counterparty_signature", }, ), ) cls.list_of_state_update_messages = (DialogueMessage( StateUpdateMessage.Performative.INITIALIZE, { "amount_by_currency_id": cls.amount_by_currency_id, "quantities_by_good_id": cls.quantities_by_good_id, }, ), ) cls.game._expected_controller_addr = COUNTERPARTY_ADDRESS