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 == ()