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
