async def test_send_act(self):
"""Test send act message."""
msg = GymMessage(
performative=GymMessage.Performative.ACT,
action=GymMessage.AnyObject("any_action"),
step_id=1,
)
msg.counterparty = "_to_key"
envelope = Envelope(
to="_to_key",
sender=self.my_address,
protocol_id=GymMessage.protocol_id,
message=msg,
)
await self.gym_con.connect()
with patch.object(self.env,
"step",
return_value=(1, 1.0, True, "some info")) as mock:
await self.gym_con.send(envelope)
mock.assert_called()
assert await asyncio.wait_for(self.gym_con.receive(),
timeout=3) is not None
def test_error_skill_unsupported_protocol(self):
"""Test the unsupported error message."""
self.my_aea._inbox._history = []
msg = FipaMessage(
message_id=1,
dialogue_reference=(str(0), ""),
target=0,
performative=FipaMessage.Performative.ACCEPT,
)
msg.to = self.address
envelope = Envelope(
to=msg.to,
sender=self.address,
message=msg,
)
self.my_error_handler.send_unsupported_protocol(envelope)
wait_for_condition(lambda: len(self.my_aea._inbox._history) >= 1,
timeout=5)
envelope = self.my_aea._inbox._history[-1]
msg = envelope.message
assert msg.performative == DefaultMessage.Performative.ERROR
assert msg.error_code == DefaultMessage.ErrorCode.UNSUPPORTED_PROTOCOL
def test_search_count_increases(self):
"""Test that the search count increases."""
request_id = 1
search_query_empty_model = Query(
[Constraint("foo", ConstraintType("==", "bar"))], model=None)
search_request = OefSearchMessage(
performative=OefSearchMessage.Performative.SEARCH_SERVICES,
dialogue_reference=(str(request_id), ""),
query=search_query_empty_model,
)
self.multiplexer.put(
Envelope(
to=DEFAULT_OEF,
sender=FETCHAI_ADDRESS_ONE,
protocol_id=OefSearchMessage.protocol_id,
message=OefSearchSerializer().encode(search_request),
))
envelope = self.multiplexer.get(block=True, timeout=5.0)
search_result = OefSearchSerializer().decode(envelope.message)
assert (search_result.performative ==
OefSearchMessage.Performative.SEARCH_RESULT)
assert search_result.dialogue_reference[0] == str(request_id)
assert request_id and search_result.agents == ()
def test_success_serialization():
"""Test the serialization for 'success' speech-act works."""
msg = OefSearchMessage(
performative=OefSearchMessage.Performative.SUCCESS,
agents_info=OefSearchMessage.AgentsInfo({
"key_1": {
"key_1": b"value_1",
"key_2": b"value_2"
},
"key_2": {
"key_3": b"value_3",
"key_4": b"value_4"
},
}),
)
msg.to = "receiver"
envelope = Envelope(
to=msg.to,
sender="sender",
protocol_id=OefSearchMessage.protocol_id,
message=msg,
)
envelope_bytes = envelope.encode()
actual_envelope = Envelope.decode(envelope_bytes)
expected_envelope = envelope
assert expected_envelope.to == actual_envelope.to
assert expected_envelope.sender == actual_envelope.sender
assert expected_envelope.protocol_id == actual_envelope.protocol_id
assert expected_envelope.message != actual_envelope.message
actual_msg = OefSearchMessage.serializer.decode(actual_envelope.message)
actual_msg.to = actual_envelope.to
actual_msg.sender = actual_envelope.sender
expected_msg = msg
assert expected_msg == actual_msg
async def test_send_close_negative(self):
"""Test send close message with invalid reference and message id and target."""
msg = GymMessage(
performative=GymMessage.Performative.CLOSE,
dialogue_reference=self.dialogues.
new_self_initiated_dialogue_reference(),
)
msg.counterparty = self.gym_address
dialogue = self.dialogues.update(msg)
assert dialogue is None
msg.sender = self.agent_address
envelope = Envelope(
to=msg.counterparty,
sender=msg.sender,
protocol_id=msg.protocol_id,
message=msg,
)
await self.gym_con.connect()
with patch.object(self.gym_con.channel.logger,
"warning") as mock_logger:
await self.gym_con.send(envelope)
mock_logger.assert_any_call(
f"Could not create dialogue from message={msg}")
def _make_response(self,
request_envelope: Envelope,
status_code: int = 200,
status_text: str = "") -> Envelope:
"""Make response envelope."""
incoming_message = cast(HttpMessage, request_envelope.message)
dialogue = self._server_dialogues.update(incoming_message)
assert dialogue is not None
message = dialogue.reply(
target_message=incoming_message,
performative=HttpMessage.Performative.RESPONSE,
version=incoming_message.version,
headers=incoming_message.headers,
status_code=status_code,
status_text=status_text,
body=incoming_message.body,
)
response_envelope = Envelope(
to=message.to,
sender=message.sender,
context=request_envelope.context,
message=message,
)
return response_envelope
def _make_request(
self, path: str, method: str = "get", headers: str = "", bodyy: bytes = b""
) -> Envelope:
"""Make request envelope."""
request_http_message = HttpMessage(
dialogue_reference=self._client_dialogues.new_self_initiated_dialogue_reference(),
target=0,
message_id=1,
performative=HttpMessage.Performative.REQUEST,
method=method,
url=f"http://{self.host}:{self.port}{path}",
headers="",
version="",
bodyy=b"",
)
request_http_message.counterparty = str(HTTPClientConnection.connection_id)
assert self._client_dialogues.update(request_http_message) is not None
request_envelope = Envelope(
to=request_http_message.counterparty,
sender=request_http_message.sender,
protocol_id=request_http_message.protocol_id,
message=request_http_message,
)
return request_envelope
async def handle_gym_message(self, envelope: Envelope) -> None:
"""
Forward a message to gym.
:param envelope: the envelope
:return: None
"""
assert isinstance(envelope.message,
GymMessage), "Message not of type GymMessage"
gym_message = cast(GymMessage, envelope.message)
if gym_message.performative == GymMessage.Performative.ACT:
action = gym_message.action.any
step_id = gym_message.step_id
observation, reward, done, info = await self._run_in_executor(
self.gym_env.step, action)
msg = GymMessage(
performative=GymMessage.Performative.PERCEPT,
observation=GymMessage.AnyObject(observation),
reward=reward,
done=done,
info=GymMessage.AnyObject(info),
step_id=step_id,
)
envelope = Envelope(
to=envelope.sender,
sender=DEFAULT_GYM,
protocol_id=GymMessage.protocol_id,
message=msg,
)
await self._send(envelope)
elif gym_message.performative == GymMessage.Performative.RESET:
await self._run_in_executor(self.gym_env.reset)
elif gym_message.performative == GymMessage.Performative.CLOSE:
await self._run_in_executor(self.gym_env.close)
async def test_bad_performative(self, caplog):
"""Test fail on bad perfromative."""
agent_location = Location(52.2057092, 2.1183431)
service_instance = {"location": agent_location}
service_description = Description(
service_instance, data_model=models.AGENT_LOCATION_MODEL)
message = OefSearchMessage(
performative="oef_error",
dialogue_reference=self.oef_search_dialogues.
new_self_initiated_dialogue_reference(),
service_description=service_description,
)
message.counterparty = SOEFConnection.connection_id.latest
sending_dialogue = self.oef_search_dialogues.update(message)
assert sending_dialogue is None
message.sender = self.crypto.address
envelope = Envelope(
to=message.counterparty,
sender=message.sender,
protocol_id=message.protocol_id,
message=message,
)
with pytest.raises(ValueError):
await self.connection.send(envelope)
async def test_erc1155_get_state(erc1155_contract, ledger_apis_connection):
"""Test get state with contract erc1155."""
contract, contract_address = erc1155_contract
address = ETHEREUM_ADDRESS_ONE
contract_api_dialogues = ContractApiDialogues(address)
token_id = 1
request, contract_api_dialogue = contract_api_dialogues.create(
counterparty=str(ledger_apis_connection.connection_id),
performative=ContractApiMessage.Performative.GET_STATE,
ledger_id=ETHEREUM,
contract_id=str(ERC1155_PUBLIC_ID),
contract_address=contract_address,
callable="get_balance",
kwargs=ContractApiMessage.Kwargs(
{"agent_address": address, "token_id": token_id}
),
)
envelope = Envelope(to=request.to, sender=request.sender, message=request,)
await ledger_apis_connection.send(envelope)
await asyncio.sleep(0.01)
response = await ledger_apis_connection.receive()
assert response is not None
assert type(response.message) == ContractApiMessage
response_message = cast(ContractApiMessage, response.message)
assert (
response_message.performative == ContractApiMessage.Performative.STATE
), "Error: {}".format(response_message.message)
response_dialogue = contract_api_dialogues.update(response_message)
assert response_dialogue == contract_api_dialogue
assert type(response_message.state) == State
assert response_message.state.ledger_id == ETHEREUM
result = response_message.state.body.get("balance", None)
expected_result = {token_id: 0}
assert result is not None and result == expected_result
def test_communication_client_server(self):
"""Test that envelopes can be sent from a client to a server."""
msg = DefaultMessage(
dialogue_reference=("", ""),
message_id=1,
target=0,
performative=DefaultMessage.Performative.BYTES,
content=b"hello",
)
expected_envelope = Envelope(
to=self.server_addr,
sender=self.client_addr_1,
protocol_id=DefaultMessage.protocol_id,
message=msg,
)
self.client_1_multiplexer.put(expected_envelope)
actual_envelope = self.server_multiplexer.get(block=True, timeout=5.0)
assert expected_envelope.to == actual_envelope.to
assert expected_envelope.sender == actual_envelope.sender
assert expected_envelope.protocol_id == actual_envelope.protocol_id
assert expected_envelope.message != actual_envelope.message
msg = DefaultMessage.serializer.decode(actual_envelope.message)
assert expected_envelope.message == msg
async def _unregister_service(
self,
address: Address,
dialogue_reference: Tuple[str, str],
service_description: Description,
) -> None:
"""
Unregister a service agent.
:param address: the address of the service agent to be unregistered.
:param dialogue_reference: the dialogue_reference.
:param service_description: the description of the service agent to be unregistered.
:return: None
"""
async with self._lock:
if address not in self.services:
msg = OefSearchMessage(
performative=OefSearchMessage.Performative.OEF_ERROR,
dialogue_reference=(dialogue_reference[0],
dialogue_reference[0]),
target=RESPONSE_TARGET,
message_id=RESPONSE_MESSAGE_ID,
oef_error_operation=OefSearchMessage.OefErrorOperation.
UNREGISTER_SERVICE,
)
envelope = Envelope(
to=address,
sender=DEFAULT_OEF,
protocol_id=OefSearchMessage.protocol_id,
message=msg,
)
await self._send(envelope)
else:
self.services[address].remove(service_description)
if len(self.services[address]) == 0:
self.services.pop(address)
def test_envelope_echoed_back_node_agent(self):
"""Test the envelope is echoed back node agent."""
addr_1 = self.connection_client_1.address
addr_n = self.connection_node_2.address
msg = DefaultMessage(
dialogue_reference=("", ""),
message_id=1,
target=0,
performative=DefaultMessage.Performative.BYTES,
content=b"hello",
)
original_envelope = Envelope(
to=addr_n,
sender=addr_1,
protocol_specification_id=DefaultMessage.protocol_specification_id,
message=DefaultSerializer().encode(msg),
)
self.multiplexer_client_1.put(original_envelope)
delivered_envelope = self.multiplexer_node_2.get(block=True,
timeout=10)
assert delivered_envelope is not None
delivered_envelope.to = addr_1
delivered_envelope.sender = addr_n
self.multiplexer_node_2.put(delivered_envelope)
echoed_envelope = self.multiplexer_client_1.get(block=True, timeout=5)
assert echoed_envelope is not None
assert echoed_envelope.to == original_envelope.sender
assert delivered_envelope.sender == original_envelope.to
assert (delivered_envelope.protocol_specification_id ==
original_envelope.protocol_specification_id)
assert delivered_envelope.message == original_envelope.message
async def test_register_personailty_pieces(self):
"""Test register service with personality pieces."""
service_instance = {"piece": "genus", "value": "service"}
service_description = Description(
service_instance, data_model=models.AGENT_PERSONALITY_MODEL)
message, _ = self.oef_search_dialogues.create(
counterparty=str(SOEFConnection.connection_id.to_any()),
performative=OefSearchMessage.Performative.REGISTER_SERVICE,
service_description=service_description,
)
envelope = Envelope(
to=message.to,
sender=message.sender,
message=message,
)
with patch.object(
self.connection.channel,
"_request_text",
make_async(self.generic_success_response),
):
await self.connection.send(envelope)
with pytest.raises(asyncio.TimeoutError): # got no message back
await asyncio.wait_for(self.connection.receive(), timeout=1)
async def test_late_message_get_timeout_error(self):
"""Test send get request w/ 200 response."""
self.http_connection.channel.RESPONSE_TIMEOUT = 1
request_task = self.loop.create_task(self.request("get", "/pets"))
envelope = await asyncio.wait_for(self.http_connection.receive(),
timeout=10)
assert envelope
incoming_message, dialogue = self._get_message_and_dialogue(envelope)
message = dialogue.reply(
target_message=incoming_message,
performative=HttpMessage.Performative.RESPONSE,
version=incoming_message.version,
headers=incoming_message.headers,
status_code=200,
status_text="Success",
body=b"Response body",
)
response_envelope = Envelope(
to=message.to,
sender=envelope.to,
context=envelope.context,
message=message,
)
await asyncio.sleep(1.5)
with patch.object(self.http_connection.logger,
"warning") as mock_logger:
await self.http_connection.send(response_envelope)
mock_logger.assert_any_call(
RegexComparator(
"Dropping message=.* for incomplete_dialogue_label=.* which has timed out."
))
response = await asyncio.wait_for(request_task, timeout=10)
assert (response.status == 408 and response.reason == "Request Timeout"
and await response.text() == "")
def _try_construct_envelope(
agent_name: str, dialogues: Dialogues,
message_class: Type[Message]) -> Optional[Envelope]:
"""Try construct an envelope from user input."""
envelope = None # type: Optional[Envelope]
try:
performative_str = "bytes"
performative = message_class.Performative(performative_str)
click.echo(
f"Provide message of protocol '{str(message_class.protocol_id)}' for performative {performative_str}:"
)
message_escaped = input() # nosec
message_escaped = message_escaped.strip()
if message_escaped == "":
raise InterruptInputException
message_decoded = codecs.decode(message_escaped.encode("utf-8"),
"unicode-escape")
message = message_decoded.encode("utf-8") # type: Union[str, bytes]
msg, _ = dialogues.create(
counterparty=agent_name,
performative=performative,
content=message,
)
envelope = Envelope(
to=msg.to,
sender=msg.sender,
protocol_id=msg.protocol_id,
message=msg,
)
except InterruptInputException:
click.echo("Interrupting input, checking inbox ...")
except KeyboardInterrupt as e:
raise e
except BaseException as e: # pylint: disable=broad-except # pragma: no cover
click.echo(e)
return envelope
async def test_server_error_on_send_response(self):
"""Test exception raised on response sending to the client."""
request_task = self.loop.create_task(self.request(
"post",
"/pets",
))
envelope = await asyncio.wait_for(self.http_connection.receive(),
timeout=20)
assert envelope
incoming_message, dialogue = self._get_message_and_dialogue(envelope)
message = dialogue.reply(
target_message=incoming_message,
performative=HttpMessage.Performative.RESPONSE,
version=incoming_message.version,
headers=incoming_message.headers,
status_code=201,
status_text="Created",
body=b"Response body",
)
response_envelope = Envelope(
to=message.to,
sender=envelope.to,
context=envelope.context,
message=message,
)
with patch.object(Response,
"from_message",
side_effect=Exception("expected")):
await self.http_connection.send(response_envelope)
response = await asyncio.wait_for(
request_task,
timeout=20,
)
assert response and response.status == 500 and response.reason == "Server Error"
def _try_construct_envelope(agent_name: str,
sender: str) -> Optional[Envelope]:
"""Try construct an envelope from user input."""
envelope = None # type: Optional[Envelope]
try:
performative_str = "bytes"
performative = DefaultMessage.Performative(performative_str)
click.echo(
"Provide message of protocol fetchai/default:0.3.0 for performative {}:"
.format(performative_str))
message_escaped = input() # nosec
message_escaped = message_escaped.strip()
if message_escaped == "":
raise InterruptInputException
if performative == DefaultMessage.Performative.BYTES:
message_decoded = codecs.decode(message_escaped.encode("utf-8"),
"unicode-escape")
message = message_decoded.encode(
"utf-8") # type: Union[str, bytes]
else:
message = message_escaped # pragma: no cover
msg = DefaultMessage(performative=performative, content=message)
envelope = Envelope(
to=agent_name,
sender=sender,
protocol_id=DefaultMessage.
protocol_id, # PublicId.from_str(protocol_id),
message=msg,
)
except InterruptInputException:
click.echo("Interrupting input, checking inbox ...")
except KeyboardInterrupt as e:
raise e
except Exception as e: # pylint: disable=broad-except # pragma: no cover
click.echo(e)
return envelope
def test_not_empty_search_result(self):
"""Test that the search result contains one entry after a successful registration."""
# build and send the request
search_services_request, sending_dialogue = self.dialogues.create(
counterparty=str(OEFLocalConnection.connection_id),
performative=OefSearchMessage.Performative.SEARCH_SERVICES,
query=Query(constraints=[], model=self.data_model),
)
envelope = Envelope(
to=search_services_request.to,
sender=search_services_request.sender,
protocol_id=search_services_request.protocol_id,
message=search_services_request,
)
self.multiplexer.put(envelope)
# check the result
response_envelope = self.multiplexer.get(block=True, timeout=2.0)
assert response_envelope.protocol_id == OefSearchMessage.protocol_id
search_result = cast(OefSearchMessage, response_envelope.message)
response_dialogue = self.dialogues.update(search_result)
assert response_dialogue == sending_dialogue
assert search_result.performative == OefSearchMessage.Performative.SEARCH_RESULT
assert search_result.agents == (self.address_1, )
def test_star_routing_connectivity(self):
"""Test star routing connectivity."""
addrs = [conn.node.address for conn in self.connections]
for source in range(len(self.multiplexers)):
for destination in range(len(self.multiplexers)):
if destination == source:
continue
msg = DefaultMessage(
dialogue_reference=("", ""),
message_id=1,
target=0,
performative=DefaultMessage.Performative.BYTES,
content=b"hello",
)
envelope = Envelope(
to=addrs[destination],
sender=addrs[source],
message=msg,
)
self.multiplexers[source].put(envelope)
delivered_envelope = self.multiplexers[destination].get(
block=True, timeout=10)
assert delivered_envelope is not None
assert delivered_envelope.to == envelope.to
assert delivered_envelope.sender == envelope.sender
assert (delivered_envelope.protocol_specification_id ==
envelope.protocol_specification_id)
assert delivered_envelope.message != envelope.message
msg = DefaultMessage.serializer.decode(
delivered_envelope.message)
msg.sender = delivered_envelope.sender
msg.to = delivered_envelope.to
assert envelope.message == msg
def test_filtered_search_result(self):
"""Test that the search result contains only the entries matching the query."""
# build and send the request
search_services_request, sending_dialogue = self.dialogues1.create(
counterparty=str(OEFLocalConnection.connection_id),
performative=OefSearchMessage.Performative.SEARCH_SERVICES,
query=Query(constraints=[], model=self.data_model_barfoo),
)
envelope = Envelope(
to=search_services_request.to,
sender=search_services_request.sender,
protocol_id=search_services_request.protocol_id,
message=search_services_request,
)
self.multiplexer1.put(envelope)
# check the result
response_envelope = InBox(self.multiplexer1).get(block=True,
timeout=5.0)
search_result = cast(OefSearchMessage, response_envelope.message)
response_dialogue = self.dialogues1.update(search_result)
assert response_dialogue == sending_dialogue
assert search_result.performative == OefSearchMessage.Performative.SEARCH_RESULT
assert search_result.agents == (self.address_2, ), self.node.services
def test_search_services_with_distance_query(self):
"""Test that a search services request can be sent correctly.
In this test, the query has a simple data model.
"""
tour_eiffel = Location(48.8581064, 2.29447)
request_id = 1
attribute = Attribute("latlon", Location, True)
data_model = DataModel("geolocation", [attribute])
search_query = Query(
[
Constraint(attribute.name,
ConstraintType("distance", (tour_eiffel, 1.0)))
],
model=data_model,
)
search_request = OefSearchMessage(
performative=OefSearchMessage.Performative.SEARCH_SERVICES,
dialogue_reference=(str(request_id), ""),
query=search_query,
)
self.multiplexer.put(
Envelope(
to=DEFAULT_OEF,
sender=FETCHAI_ADDRESS_ONE,
protocol_id=OefSearchMessage.protocol_id,
message=OefSearchSerializer().encode(search_request),
))
envelope = self.multiplexer.get(block=True, timeout=5.0)
search_result = OefSearchSerializer().decode(envelope.message)
print("HERE:" + str(search_result))
assert (search_result.performative ==
OefSearchMessage.Performative.SEARCH_RESULT)
assert search_result.dialogue_reference[0] == str(request_id)
assert search_result.agents == ()
def test_cancelled_serialization():
"""Test the serialization for 'cancelled' speech-act works."""
msg = TacMessage(performative=TacMessage.Performative.CANCELLED, )
msg.to = "receiver"
envelope = Envelope(
to=msg.to,
sender="sender",
message=msg,
)
envelope_bytes = envelope.encode()
actual_envelope = Envelope.decode(envelope_bytes)
expected_envelope = envelope
assert expected_envelope.to == actual_envelope.to
assert expected_envelope.sender == actual_envelope.sender
assert (expected_envelope.protocol_specification_id ==
actual_envelope.protocol_specification_id)
assert expected_envelope.message != actual_envelope.message
actual_msg = TacMessage.serializer.decode(actual_envelope.message)
actual_msg.to = actual_envelope.to
actual_msg.sender = actual_envelope.sender
expected_msg = msg
assert expected_msg == actual_msg
def test_performative_inform():
"""Test the serialization-deserialization of the inform performative."""
msg = FipaMessage(
message_id=1,
dialogue_reference=(str(0), ""),
target=0,
performative=FipaMessage.Performative.INFORM,
info={"foo": "bar"},
)
msg_bytes = FipaSerializer().encode(msg)
envelope = Envelope(
to="receiver",
sender="sender",
protocol_id=FipaMessage.protocol_id,
message=msg_bytes,
)
envelope_bytes = envelope.encode()
actual_envelope = Envelope.decode(envelope_bytes)
expected_envelope = envelope
assert expected_envelope == actual_envelope
deserialised_msg = FipaSerializer().decode(envelope.message)
assert msg.get("performative") == deserialised_msg.get("performative")
async def test_register_personailty_pieces(self):
"""Test register service with personality pieces."""
service_instance = {"piece": "genus", "value": "service"}
service_description = Description(
service_instance, data_model=models.AGENT_PERSONALITY_MODEL)
message = OefSearchMessage(
performative=OefSearchMessage.Performative.REGISTER_SERVICE,
service_description=service_description,
)
envelope = Envelope(
to="soef",
sender=self.crypto.address,
protocol_id=message.protocol_id,
message=message,
)
with patch.object(
self.connection.channel,
"_request_text",
make_async(self.generic_success_response),
):
await self.connection.send(envelope)
with pytest.raises(asyncio.TimeoutError): # got no message back
await asyncio.wait_for(self.connection.receive(), timeout=1)
async def test_send_cancelled():
"""Test that cancelling a send works correctly."""
port = get_unused_tcp_port()
tcp_server = _make_tcp_server_connection("address_server", "127.0.0.1",
port)
tcp_client = _make_tcp_client_connection("address_client", "127.0.0.1",
port)
await tcp_server.connect()
await tcp_client.connect()
with unittest.mock.patch.object(tcp_client._writer,
"drain",
side_effect=CancelledError):
envelope = Envelope(
to="address_client",
sender="address_server",
protocol_id=DefaultMessage.protocol_id,
message=b"",
)
await tcp_client.send(envelope)
await tcp_client.disconnect()
await tcp_server.disconnect()
def test_error_decoding_error(self):
"""Test the decoding error."""
self.my_aea._inbox._history = []
msg = FipaMessage(
message_id=1,
dialogue_reference=(str(0), ""),
target=0,
performative=FipaMessage.Performative.ACCEPT,
)
msg.to = self.address
envelope = Envelope(
to=msg.to,
sender=self.address,
message=msg,
)
self.my_error_handler.send_decoding_error(envelope)
wait_for_condition(lambda: len(self.my_aea._inbox._history) >= 1,
timeout=5)
envelope = self.my_aea._inbox._history[-1]
msg = envelope.message
assert msg.performative == DefaultMessage.Performative.ERROR
assert msg.error_code == DefaultMessage.ErrorCode.DECODING_ERROR
async def test_unregister_service(self):
"""Test unregister service."""
agent_location = Location(52.2057092, 2.1183431)
service_instance = {"location": agent_location}
service_description = Description(
service_instance, data_model=models.AGENT_LOCATION_MODEL)
message, _ = self.oef_search_dialogues.create(
counterparty=str(SOEFConnection.connection_id.to_any()),
performative=OefSearchMessage.Performative.UNREGISTER_SERVICE,
service_description=service_description,
)
envelope = Envelope(
to=message.to,
sender=message.sender,
message=message,
)
with patch.object(
self.connection.channel,
"_request_text",
make_async("<response><message>Goodbye!</message></response>"),
):
await self.connection.send(envelope)
assert self.connection.channel.unique_page_address is None
def setup_class(cls):
"""Set up the test."""
cls.node = LocalNode()
cls.node.start()
cls.address_1 = "multiplexer1"
cls.address_2 = "multiplexer2"
cls.multiplexer1 = Multiplexer(
[_make_local_connection(
cls.address_1,
cls.node,
)])
cls.multiplexer2 = Multiplexer(
[_make_local_connection(
cls.address_2,
cls.node,
)])
cls.multiplexer1.connect()
cls.multiplexer2.connect()
cls.dialogues1 = OefSearchDialogues(cls.address_1)
cls.dialogues2 = OefSearchDialogues(cls.address_2)
# register 'multiplexer1' as a service 'foobar'.
cls.data_model_foobar = DataModel(
"foobar",
attributes=[
Attribute("foo", int, True),
Attribute("bar", str, True)
],
)
service_description = Description({
"foo": 1,
"bar": "baz"
},
data_model=cls.data_model_foobar)
register_service_request, sending_dialogue = cls.dialogues1.create(
counterparty=str(OEFLocalConnection.connection_id),
performative=OefSearchMessage.Performative.REGISTER_SERVICE,
service_description=service_description,
)
envelope = Envelope(
to=register_service_request.to,
sender=register_service_request.sender,
message=register_service_request,
)
cls.multiplexer1.put(envelope)
wait_for_condition(lambda: len(cls.node.services) == 1, timeout=10)
# register 'multiplexer2' as a service 'barfoo'.
cls.data_model_barfoo = DataModel(
"barfoo",
attributes=[
Attribute("foo", int, True),
Attribute("bar", str, True)
],
)
service_description = Description({
"foo": 1,
"bar": "baz"
},
data_model=cls.data_model_barfoo)
register_service_request, sending_dialogue = cls.dialogues2.create(
counterparty=str(OEFLocalConnection.connection_id),
performative=OefSearchMessage.Performative.REGISTER_SERVICE,
service_description=service_description,
)
envelope = Envelope(
to=register_service_request.to,
sender=register_service_request.sender,
message=register_service_request,
)
cls.multiplexer2.put(envelope)
wait_for_condition(lambda: len(cls.node.services) == 2, timeout=10)
# unregister multiplexer1
data_model = DataModel(
"foobar",
attributes=[
Attribute("foo", int, True),
Attribute("bar", str, True)
],
)
service_description = Description({
"foo": 1,
"bar": "baz"
},
data_model=data_model)
msg, sending_dialogue = cls.dialogues1.create(
counterparty=str(OEFLocalConnection.connection_id),
performative=OefSearchMessage.Performative.UNREGISTER_SERVICE,
service_description=service_description,
)
envelope = Envelope(
to=msg.to,
sender=msg.sender,
message=msg,
)
cls.multiplexer1.put(envelope)
# ensure one service stays registered
wait_for_condition(lambda: len(cls.node.services) == 1, timeout=10)
def test_unregister_service_result(self):
"""Test that at the beginning, the search request returns an empty search result."""
data_model = DataModel(
"foobar",
attributes=[
Attribute("foo", int, True),
Attribute("bar", str, True)
],
)
service_description = Description({
"foo": 1,
"bar": "baz"
},
data_model=data_model)
msg, sending_dialogue = self.dialogues.create(
counterparty=str(OEFLocalConnection.connection_id),
performative=OefSearchMessage.Performative.UNREGISTER_SERVICE,
service_description=service_description,
)
envelope = Envelope(
to=msg.to,
sender=msg.sender,
message=msg,
)
self.multiplexer1.put(envelope)
# check the result
response_envelope = self.multiplexer1.get(block=True, timeout=5.0)
assert (response_envelope.protocol_specification_id ==
OefSearchMessage.protocol_specification_id)
response = cast(OefSearchMessage, response_envelope.message)
response_dialogue = self.dialogues.update(response)
assert response_dialogue == sending_dialogue
assert response.performative == OefSearchMessage.Performative.OEF_ERROR
msg, sending_dialogue = self.dialogues.create(
counterparty=str(OEFLocalConnection.connection_id),
performative=OefSearchMessage.Performative.REGISTER_SERVICE,
service_description=service_description,
)
envelope = Envelope(
to=msg.to,
sender=msg.sender,
message=msg,
)
self.multiplexer1.put(envelope)
# Search for the registered service
msg, sending_dialogue = self.dialogues.create(
counterparty=str(OEFLocalConnection.connection_id),
performative=OefSearchMessage.Performative.SEARCH_SERVICES,
query=Query([Constraint("foo", ConstraintType("==", 1))]),
)
envelope = Envelope(
to=msg.to,
sender=msg.sender,
message=msg,
)
self.multiplexer1.put(envelope)
# check the result
response_envelope = self.multiplexer1.get(block=True, timeout=5.0)
search_result = cast(OefSearchMessage, response_envelope.message)
response_dialogue = self.dialogues.update(search_result)
assert response_dialogue == sending_dialogue
assert search_result.performative == OefSearchMessage.Performative.SEARCH_RESULT
assert len(search_result.agents) == 1
# unregister the service
msg, sending_dialogue = self.dialogues.create(
counterparty=str(OEFLocalConnection.connection_id),
performative=OefSearchMessage.Performative.UNREGISTER_SERVICE,
service_description=service_description,
)
envelope = Envelope(
to=msg.to,
sender=msg.sender,
message=msg,
)
self.multiplexer1.put(envelope)
# the same query returns empty
# Search for the register agent
msg, sending_dialogue = self.dialogues.create(
counterparty=str(OEFLocalConnection.connection_id),
performative=OefSearchMessage.Performative.SEARCH_SERVICES,
query=Query([Constraint("foo", ConstraintType("==", 1))]),
)
envelope = Envelope(
to=msg.to,
sender=msg.sender,
message=msg,
)
self.multiplexer1.put(envelope)
# check the result
response_envelope = self.multiplexer1.get(block=True, timeout=5.0)
search_result = cast(OefSearchMessage, response_envelope.message)
response_dialogue = self.dialogues.update(search_result)
assert response_dialogue == sending_dialogue
assert search_result.performative == OefSearchMessage.Performative.SEARCH_RESULT
assert search_result.agents == ()
