def test_constraint(): """Test Constraint.""" c1 = Constraint("author", ConstraintType("==", "Stephen King")) c2 = Constraint("author", ConstraintType("in", ["Stephen King"])) book_1 = Description({ "author": "Stephen King", "year": 1991, "genre": "horror" }) book_2 = Description({ "author": "George Orwell", "year": 1948, "genre": "horror" }) assert c1.check(book_1) assert not c1.check(book_2) # empty description assert not c1.check(Description({})) # bad type assert not c1.check(Description({"author": 12})) # bad type assert not c2.check(Description({"author": 12})) assert c1.is_valid(generate_data_model("test", {"author": "some author"})) assert not c1.is_valid( generate_data_model("test", {"not_author": "some author"})) assert c1 == c1 assert c1 != c2
def test_is_acceptable_proposal(self): """Test the is_acceptable_proposal method of the GenericStrategy class.""" acceptable_description = Description({ "ledger_id": self.ledger_id, "price": 150, "currency_id": self.currency_id, "service_id": self.service_id, "quantity": 10, "tx_nonce": "some_tx_nonce", }) is_acceptable = self.strategy.is_acceptable_proposal( acceptable_description) assert is_acceptable unacceptable_description = Description({ "ledger_id": self.ledger_id, "price": 250, "currency_id": self.currency_id, "service_id": self.service_id, "quantity": 10, "tx_nonce": "some_tx_nonce", }) is_acceptable = self.strategy.is_acceptable_proposal( unacceptable_description) assert not is_acceptable
def test_fipa_propose_serialization(): """Test that the serialization for the 'fipa' protocol works.""" proposal = [ Description({"foo1": 1, "bar1": 2}), Description({"foo2": 1, "bar2": 2}), ] msg = FIPAMessage( message_id=0, dialogue_reference=(str(0), ""), target=0, performative=FIPAMessage.Performative.PROPOSE, proposal=proposal, ) 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 actual_msg = FIPASerializer().decode(actual_envelope.message) expected_msg = msg p1 = actual_msg.get("proposal") p2 = expected_msg.get("proposal") assert p1[0].values == p2[0].values assert p1[1].values == p2[1].values
def test_constraints_expression(): """Test constraint expressions: And, Or, Not, Constraint.""" and_expression = And([ Constraint("number", ConstraintType(ConstraintTypes.LESS_THAN, 15)), Constraint("number", ConstraintType(ConstraintTypes.GREATER_THAN, 10)), ]) and_expression.check_validity() assert and_expression.check(Description({"number": 12})) assert and_expression.is_valid( DataModel("some_name", [Attribute("number", int, True)])) and_expression_pb = ConstraintExpr._encode(and_expression) actual_and_expression = ConstraintExpr._decode(and_expression_pb) assert actual_and_expression == and_expression or_expression = Or([ Constraint("number", ConstraintType(ConstraintTypes.EQUAL, 12)), Constraint("number", ConstraintType(ConstraintTypes.EQUAL, 13)), ]) or_expression.check_validity() assert or_expression.check(Description({"number": 12})) assert or_expression.is_valid( DataModel("some_name", [Attribute("number", int, True)])) or_expression_pb = ConstraintExpr._encode(or_expression) actual_or_expression = ConstraintExpr._decode(or_expression_pb) assert actual_or_expression == or_expression not_expression = Not( And([ Constraint("number", ConstraintType(ConstraintTypes.EQUAL, 12)), Constraint("number", ConstraintType(ConstraintTypes.EQUAL, 12)), ])) not_expression.check_validity() assert not_expression.check(Description({"number": 13})) assert not_expression.is_valid( DataModel("some_name", [Attribute("number", int, True)])) not_expression_pb = ConstraintExpr._encode(not_expression) actual_not_expression = ConstraintExpr._decode(not_expression_pb) assert actual_not_expression == not_expression # constraint constraint_expression = Constraint("author", ConstraintType("==", "Stephen King")) constraint_expression.check_validity() assert constraint_expression.check(Description({"author": "Stephen King"})) assert constraint_expression.is_valid( DataModel("some_name", [Attribute("author", str, True)])) constraint_expression_pb = ConstraintExpr._encode(constraint_expression) actual_constraint_expression = ConstraintExpr._decode( constraint_expression_pb) assert actual_constraint_expression == constraint_expression incorrect_expression = Location(1.1, 2.2) with pytest.raises( ValueError, match= f"Invalid expression type. Expected either of 'And', 'Or', 'Not', 'Constraint'. Found {type(incorrect_expression)}.", ): ConstraintExpr._encode(incorrect_expression)
def setup(cls): """Setup the test class.""" super().setup() cls.service_behaviour = cast( ServiceRegistrationBehaviour, cls._skill.skill_context.behaviours.service ) cls.strategy = cast(Strategy, cls._skill.skill_context.strategy) cls.logger = cls._skill.skill_context.logger cls.mocked_description_1 = Description({"foo1": 1, "bar1": 2}) cls.mocked_description_2 = Description({"foo2": 1, "bar2": 2})
def test__get_proposal_for_query(self): """Test the _get_proposal_for_query method of the Strategy class.""" # setup is_seller = True mocked_query = Query( [ Constraint("some_attribute_name", ConstraintType("==", "some_value")) ], DataModel( "some_data_model_name", [ Attribute( "some_attribute_name", str, False, "Some attribute descriptions.", ) ], ), ) proposal_1 = Description({ "some_attribute_name": "some_value", "ledger_id": self.ledger_id, "price": 100, "currency_id": "1", "fee": 1, "nonce": self.nonce, }) proposal_2 = Description({ "some_attribute_name": "some_value", "ledger_id": self.ledger_id, "price": -100, "currency_id": "1", "fee": 2, "nonce": self.nonce, }) mocked_candidate_proposals = [proposal_1, proposal_2] # operation with patch.object( self.strategy, "_generate_candidate_proposals", return_value=mocked_candidate_proposals, ) as mock_candid: actual_query = self.strategy._get_proposal_for_query( mocked_query, is_seller) # after mock_candid.assert_any_call(is_seller) assert actual_query in mocked_candidate_proposals
def test_propose(self): """Test that a Propose can be sent correctly.""" propose_empty = FipaMessage( message_id=1, dialogue_reference=(str(0), ""), target=0, performative=FipaMessage.Performative.PROPOSE, proposal=Description({"foo": "bar"}), ) propose_empty.to = FETCHAI_ADDRESS_TWO propose_empty.sender = FETCHAI_ADDRESS_ONE self.multiplexer1.put( Envelope( to=propose_empty.to, sender=propose_empty.sender, protocol_id=propose_empty.protocol_id, message=propose_empty, )) envelope = self.multiplexer2.get(block=True, timeout=2.0) expected_propose_empty = FipaMessage.serializer.decode( envelope.message) expected_propose_empty.to = propose_empty.to expected_propose_empty.sender = propose_empty.sender assert expected_propose_empty == propose_empty propose_descriptions = FipaMessage( message_id=1, dialogue_reference=(str(0), ""), target=0, performative=FipaMessage.Performative.PROPOSE, proposal=Description({"foo": "bar"}, DataModel("foobar", [Attribute("foo", str, True)])), ) propose_descriptions.to = FETCHAI_ADDRESS_TWO propose_descriptions.sender = FETCHAI_ADDRESS_ONE self.multiplexer1.put( Envelope( to=propose_descriptions.to, sender=propose_descriptions.sender, protocol_id=propose_descriptions.protocol_id, message=propose_descriptions, )) envelope = self.multiplexer2.get(block=True, timeout=2.0) expected_propose_descriptions = FipaMessage.serializer.decode( envelope.message) expected_propose_descriptions.to = propose_descriptions.to expected_propose_descriptions.sender = propose_descriptions.sender assert expected_propose_descriptions == propose_descriptions
def test_propose_serialization(): """Test that the serialization for the 'fipa' protocol works.""" msg = FipaMessage( message_id=1, dialogue_reference=(str(0), ""), target=0, performative=FipaMessage.Performative.PROPOSE, proposal=Description({ "foo1": 1, "bar1": 2 }), ) msg.to = "receiver" envelope = Envelope( to=msg.to, sender="sender", protocol_id=FipaMessage.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 = FipaMessage.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_query(): """Test Query.""" c1 = Constraint("author", ConstraintType("==", "Stephen King")) query = Query([c1]) query.check_validity() assert query.check( Description({"author": "Stephen King", "year": 1991, "genre": "horror"}) ) assert query.is_valid(generate_data_model("test", {"author": "some author"})) with pytest.raises(ValueError, match=r"Constraints must be a list .*"): query = Query(c1) Query([]).check_validity() with pytest.raises( ValueError, match=r"Invalid input value for type 'Query': the query is not valid for the given data model.", ): Query( [c1], generate_data_model("test", {"notauthor": "not some author"}) ).check_validity() assert Query([]) == Query([]) mock = Mock() Query.encode(mock, Query([])) assert Query.decode(mock) == Query([])
def _register_tac(self) -> None: """ Register on the OEF as a TAC controller agent. :return: None. """ self._oef_msg_id += 1 desc = Description( {"version": self.context.parameters.version_id}, data_model=CONTROLLER_DATAMODEL, ) self.context.logger.info("[{}]: Registering TAC data model".format( self.context.agent_name)) oef_msg = OEFMessage( type=OEFMessage.Type.REGISTER_SERVICE, id=self._oef_msg_id, service_description=desc, service_id="", ) self.context.outbox.put_message( to=DEFAULT_OEF, sender=self.context.agent_address, protocol_id=OEFMessage.protocol_id, message=OEFSerializer().encode(oef_msg), ) self._registered_desc = desc
def setup_class(cls): """Set up the test.""" cls.node = LocalNode() cls.node.start() cls.address_1 = "address" cls.multiplexer = Multiplexer( [_make_local_connection(cls.address_1, cls.node,)] ) cls.multiplexer.connect() # register a service. request_id = 1 cls.data_model = DataModel("foobar", attributes=[]) service_description = Description( {"foo": 1, "bar": "baz"}, data_model=cls.data_model ) register_service_request = OefSearchMessage( performative=OefSearchMessage.Performative.REGISTER_SERVICE, dialogue_reference=(str(request_id), ""), service_description=service_description, ) msg_bytes = OefSearchSerializer().encode(register_service_request) envelope = Envelope( to=DEFAULT_OEF, sender=cls.address_1, protocol_id=OefSearchMessage.protocol_id, message=msg_bytes, ) cls.multiplexer.put(envelope)
def test_ping(self): """Test ping command.""" agent_location = Location(*self.LOCATION) agent = Instance(agent_location) agent.start() try: service_description = Description({}, data_model=models.PING_MODEL) message, _ = agent.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=agent.crypto.address, protocol_id=message.protocol_id, message=message, ) logger.info("Pinging") agent.multiplexer.put(envelope) time.sleep(3) assert agent.multiplexer.in_queue.empty() finally: agent.stop()
def generate_proposal_and_data( self, query: Query, counterparty: Address) -> Tuple[Description, Dict[str, str]]: """ Generate a proposal matching the query. :param counterparty: the counterparty of the proposal. :param query: the query :return: a tuple of proposal and the weather data """ if self.is_ledger_tx: tx_nonce = self.context.ledger_apis.generate_tx_nonce( identifier=self._ledger_id, seller=self.context.agent_addresses[self._ledger_id], client=counterparty, ) else: tx_nonce = uuid.uuid4().hex assert (self._total_price - self._seller_tx_fee > 0), "This sale would generate a loss, change the configs!" proposal = Description({ "price": self._total_price, "seller_tx_fee": self._seller_tx_fee, "currency_id": self._currency_id, "ledger_id": self._ledger_id, "tx_nonce": tx_nonce, }) return proposal, self._data_for_sale
def _register_tac(self, parameters) -> None: """ Register on the OEF as a TAC controller agent. :return: None. """ self._oef_msg_id += 1 desc = Description( {"version": parameters.version_id}, data_model=CONTROLLER_DATAMODEL, ) self.context.logger.info( "[{}]: Registering TAC data model".format(self.context.agent_name) ) oef_msg = OefSearchMessage( performative=OefSearchMessage.Performative.REGISTER_SERVICE, dialogue_reference=(str(self._oef_msg_id), ""), service_description=desc, ) self.context.outbox.put_message( to=self.context.search_service_address, sender=self.context.agent_address, protocol_id=OefSearchMessage.protocol_id, message=OefSearchSerializer().encode(oef_msg), ) self._registered_desc = desc self.context.logger.info( "[{}]: TAC open for registration until: {}".format( self.context.agent_name, parameters.registration_end_time ) )
def test_terms_from_proposal_buyer(self): """Test the terms_from_proposal method of the Strategy class where is_seller is False.""" proposal = Description({ "2": 5, "ledger_id": self.ledger_id, "price": 100, "currency_id": "FET", "fee": 1, "nonce": self.nonce, }) role = FipaDialogue.Role.BUYER is_seller = False expected_terms = Terms( ledger_id=self.ledger_id, sender_address=self.sender, counterparty_address=self.counterparty, amount_by_currency_id={ proposal.values["currency_id"]: -proposal.values["price"] }, quantities_by_good_id={"2": 5}, is_sender_payable_tx_fee=not is_seller, nonce=self.nonce, fee_by_currency_id={ proposal.values["currency_id"]: proposal.values["fee"] }, ) actual_terms = self.strategy.terms_from_proposal( proposal, self.sender, self.counterparty, role) assert actual_terms == expected_terms
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, protocol_id=message.protocol_id, 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
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, 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_bad_register_service(self): """Test register service fails on bad values provided.""" bad_location_model = DataModel( "not_location_agent", [ Attribute("non_location", Location, True, "The location where the agent is.") ], "A data model to describe location of an agent.", ) agent_location = Location(52.2057092, 2.1183431) service_instance = {"non_location": agent_location} service_description = Description(service_instance, data_model=bad_location_model) message, sending_dialogue = 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, protocol_id=message.protocol_id, message=message, ) await self.connection.send(envelope) expected_envelope = await asyncio.wait_for(self.connection.receive(), timeout=1) assert expected_envelope assert (expected_envelope.message.performative == OefSearchMessage.Performative.OEF_ERROR) message = expected_envelope.message receiving_dialogue = self.oef_search_dialogues.update(message) assert sending_dialogue == receiving_dialogue
async def test_remove_service_key(self): """Test remove service key.""" await self.test_set_service_key() service_instance = {"key": "test"} service_description = Description( service_instance, data_model=models.REMOVE_SERVICE_KEY_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, 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)
def test_accept_serialization(): """Test the serialization for 'accept' speech-act works.""" msg = MlTradeMessage( performative=MlTradeMessage.Performative.ACCEPT, terms=Description({ "foo1": 1, "bar1": 2 }), tx_digest="some_tx_digest", ) 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 = MlTradeMessage.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_unregister_service_serialization(): """Test the serialization for 'unregister_service' speech-act works.""" msg = OefSearchMessage( message_id=2, target=1, performative=OefSearchMessage.Performative.UNREGISTER_SERVICE, service_description=Description({ "foo1": 1, "bar1": 2 }), ) 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
def register_location(self, disclosure_accuracy: Optional[str] = None) -> None: """Register location.""" service_instance: Dict[str, Any] = {"location": self.location} if disclosure_accuracy: service_instance["disclosure_accuracy"] = disclosure_accuracy 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.REGISTER_SERVICE, service_description=service_description, ) envelope = Envelope( to=message.to, sender=message.sender, message=message, ) logger.info("Registering agent at location=({},{}) by agent={}".format( self.location.latitude, self.location.longitude, self.crypto.address, )) self.multiplexer.put(envelope)
def get_unregister_tac_description(self) -> Description: """Get the tac description for unregistering.""" description = Description( self.context.parameters.remove_service_data, data_model=AGENT_REMOVE_SERVICE_MODEL, ) return description
def test_data_serialization(): """Test the serialization for 'data' speech-act works.""" msg = MlTradeMessage( performative=MlTradeMessage.Performative.DATA, terms=Description({ "foo1": 1, "bar1": 2 }), payload=b"some_payload", ) msg.to = "receiver" envelope = Envelope( to=msg.to, sender="sender", protocol_id=MlTradeMessage.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 = MlTradeMessage.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_register_service(self): """Test register 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 = OefSearchMessage( performative=OefSearchMessage.Performative.REGISTER_SERVICE, 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 not None envelope = Envelope( to=message.counterparty, 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) assert self.connection.channel.agent_location == agent_location
def test_terms_serialization(): """Test the serialization for 'terms' speech-act works.""" msg = MlTradeMessage( message_id=2, target=1, performative=MlTradeMessage.Performative.TERMS, terms=Description({ "foo1": 1, "bar1": 2 }), ) 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 = MlTradeMessage.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_bad_register_service(self): """Test register service fails on bad values provided.""" bad_location_model = DataModel( "not_location_agent", [ Attribute("non_location", Location, True, "The location where the agent is.") ], "A data model to describe location of an agent.", ) agent_location = Location(52.2057092, 2.1183431) service_instance = {"non_location": agent_location} service_description = Description(service_instance, data_model=bad_location_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, ) await self.connection.send(envelope) expected_envelope = await asyncio.wait_for(self.connection.receive(), timeout=1) assert expected_envelope assert (expected_envelope.message.performative == OefSearchMessage.Performative.OEF_ERROR)
async def test_ping_command(self): """Test set service key.""" service_description = Description({}, data_model=models.PING_MODEL) message = OefSearchMessage( performative=OefSearchMessage.Performative.REGISTER_SERVICE, 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 not None envelope = Envelope( to=message.counterparty, 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_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 = OefSearchMessage( performative=OefSearchMessage.Performative.UNREGISTER_SERVICE, 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 not None envelope = Envelope( to=message.counterparty, sender=self.crypto.address, protocol_id=message.protocol_id, 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 build_goods_description( good_id_to_quantities: Dict[str, int], currency_id: str, is_supply: bool, is_search_description: bool, ) -> Description: """ Get the service description (good quantities supplied or demanded and their price). :param good_id_to_quantities: a dictionary mapping the ids of the goods to the quantities. :param currency_id: the currency used for pricing and transacting. :param is_supply: True if the description is indicating supply, False if it's indicating demand. :param is_search_description: Whether or not the description is used for search :return: the description to advertise on the Service Directory. """ _good_id_to_quantities = copy.copy(good_id_to_quantities) if is_search_description: # the OEF does not accept attribute names consisting of integers only _good_id_to_quantities = { PREFIX + good_id: quantity for good_id, quantity in _good_id_to_quantities.items() } data_model = _build_goods_datamodel(good_ids=list( _good_id_to_quantities.keys()), is_supply=is_supply) values = cast(Dict[str, Union[int, str]], _good_id_to_quantities) values.update({"currency_id": currency_id}) desc = Description(values, data_model=data_model) return desc