def test_envelope_initialisation(): """Testing the envelope initialisation.""" agent_address = "Agent0" receiver_address = "Agent1" msg = Message(content="hello") msg.counterparty = receiver_address assert Envelope( to=receiver_address, sender=agent_address, protocol_id=UNKNOWN_PROTOCOL_PUBLIC_ID, message=msg, ), "Cannot generate a new envelope" envelope = Envelope( to=receiver_address, sender=agent_address, protocol_id=UNKNOWN_PROTOCOL_PUBLIC_ID, message=msg, ) envelope.to = "ChangedAgent" envelope.sender = "ChangedSender" envelope.protocol_id = "my_changed_protocol" envelope.message = b"HelloWorld" assert envelope.to == "ChangedAgent", "Cannot set to value on Envelope" assert envelope.sender == "ChangedSender", "Cannot set sender value on Envelope" assert ( envelope.protocol_id == "my_changed_protocol" ), "Cannot set protocol_id on Envelope " assert envelope.message == b"HelloWorld", "Cannot set message on Envelope" assert envelope.context.uri_raw is not None
def handle(self, message: Message, sender: str) -> None: """ Implement the reaction to a message. :param message: the message :param sender: the sender :return: None """ # convenience representations fipa_msg = cast(FIPAMessage, message) msg_performative = FIPAMessage.Performative(message.get('performative')) message_id = cast(int, message.get("message_id")) # recover dialogue dialogues = cast(Dialogues, self.context.dialogues) if dialogues.is_belonging_to_registered_dialogue(fipa_msg, sender, self.context.agent_public_key): dialogue = cast(Dialogue, dialogues.get_dialogue(fipa_msg, sender, self.context.agent_public_key)) dialogue.incoming_extend(fipa_msg) else: self._handle_unidentified_dialogue(fipa_msg, sender) return # handle message if msg_performative == FIPAMessage.Performative.PROPOSE: self._handle_propose(fipa_msg, sender, message_id, dialogue) elif msg_performative == FIPAMessage.Performative.DECLINE: self._handle_decline(fipa_msg, sender, message_id, dialogue) elif msg_performative == FIPAMessage.Performative.MATCH_ACCEPT_W_ADDRESS: self._handle_match_accept(fipa_msg, sender, message_id, dialogue) elif msg_performative == FIPAMessage.Performative.INFORM: self._handle_inform(fipa_msg, sender, message_id, dialogue)
def handle(self, message: Message) -> None: """ Handle an internal message from the skills. :param message: the internal message :return: None """ message.counterparty = uuid4().hex # TODO: temporary fix only message.is_incoming = True self.decision_maker_handler.handle(message)
def test_to(self): """Test the 'to' attribute getter and setter.""" message = Message() with pytest.raises(ValueError, match="Message's 'To' field must be set."): message.to message.to = "to" assert message.to == "to" with pytest.raises(AEAEnforceError, match="To already set."): message.to = "to"
def test_to(self): """Test the 'to' attribute getter and setter.""" message = Message() with pytest.raises(AssertionError, match="To must not be None."): message.to message.to = "to" assert message.to == "to" with pytest.raises(AssertionError, match="To already set."): message.to = "to"
def _message_to_percept(self, message: Message) -> Feedback: """ Transform the message received from the gym environment into observation, reward, done, info. :param: the message received as a response to the action performed in apply_action. :return: the standard feedback (observation, reward, done, info) of a gym environment. """ observation = cast(Any, message.get("observation")) reward = cast(float, message.get("reward")) done = cast(bool, message.get("done")) info = cast(dict, message.get("info")) return observation, reward, done, info
def _check_consistency(message: Message, to: str, sender: str) -> Message: """Check consistency of sender and to.""" if message.has_to: enforce(message.to == to, "To specified on message does not match envelope.") else: message.to = to if message.has_sender: enforce( message.sender == sender, "Sender specified on message does not match envelope.", ) else: message.sender = sender return message
def encode(self, msg: Message) -> bytes: """ Decode the message. :param msg: the message object :return: the bytes """ performative = GymMessage.Performative(msg.get("performative")) new_body = copy.copy(msg.body) new_body["performative"] = performative.value if performative == GymMessage.Performative.ACT: action = msg.body["action"] # type: Any action_bytes = base64.b64encode( pickle.dumps(action)).decode("utf-8") new_body["action"] = action_bytes new_body["step_id"] = msg.body["step_id"] elif performative == GymMessage.Performative.PERCEPT: # observation, reward and info are gym implementation specific, done is boolean observation = msg.body["observation"] # type: Any observation_bytes = base64.b64encode( pickle.dumps(observation)).decode("utf-8") new_body["observation"] = observation_bytes reward = msg.body["reward"] # type: Any reward_bytes = base64.b64encode( pickle.dumps(reward)).decode("utf-8") new_body["reward"] = reward_bytes info = msg.body["info"] # type: Any info_bytes = base64.b64encode(pickle.dumps(info)).decode("utf-8") new_body["info"] = info_bytes new_body["step_id"] = msg.body["step_id"] gym_message_bytes = json.dumps(new_body).encode("utf-8") return gym_message_bytes
def encode(self, msg: Message) -> bytes: """ Decode the message. :param msg: the message object :return: the bytes """ oef_type = OEFMessage.Type(msg.get("type")) new_body = copy.copy(msg.body) new_body["type"] = oef_type.value if oef_type in {OEFMessage.Type.REGISTER_SERVICE, OEFMessage.Type.UNREGISTER_SERVICE}: service_description = msg.body["service_description"] # type: Description service_description_bytes = base64.b64encode(pickle.dumps(service_description)).decode("utf-8") new_body["service_description"] = service_description_bytes elif oef_type in {OEFMessage.Type.REGISTER_AGENT, OEFMessage.Type.UNREGISTER_AGENT}: agent_description = msg.body["agent_description"] # type: Description agent_description_bytes = base64.b64encode(pickle.dumps(agent_description)).decode("utf-8") new_body["agent_description"] = agent_description_bytes elif oef_type in {OEFMessage.Type.SEARCH_SERVICES, OEFMessage.Type.SEARCH_AGENTS}: query = msg.body["query"] # type: Query query_bytes = base64.b64encode(pickle.dumps(query)).decode("utf-8") new_body["query"] = query_bytes elif oef_type in {OEFMessage.Type.SEARCH_RESULT}: # we need this cast because the "agents" field might contains # the Protobuf type "RepeatedScalarContainer", which is not JSON serializable. new_body["agents"] = list(msg.body["agents"]) elif oef_type in {OEFMessage.Type.OEF_ERROR}: operation = msg.body["operation"] new_body["operation"] = str(operation) oef_message_bytes = json.dumps(new_body).encode("utf-8") return oef_message_bytes
def test_envelope_initialisation(): """Testing the envelope initialisation.""" msg = Message(content="hello") message_bytes = ProtobufSerializer().encode(msg) assert Envelope( to="Agent1", sender="Agent0", protocol_id=UNKNOWN_PROTOCOL_PUBLIC_ID, message=message_bytes, ), "Cannot generate a new envelope" envelope = Envelope( to="Agent1", sender="Agent0", protocol_id=UNKNOWN_PROTOCOL_PUBLIC_ID, message=message_bytes, ) envelope.to = "ChangedAgent" envelope.sender = "ChangedSender" envelope.protocol_id = "my_changed_protocol" envelope.message = b"HelloWorld" assert envelope.to == "ChangedAgent", "Cannot set to value on Envelope" assert envelope.sender == "ChangedSender", "Cannot set sender value on Envelope" assert (envelope.protocol_id == "my_changed_protocol" ), "Cannot set protocol_id on Envelope " assert envelope.message == b"HelloWorld", "Cannot set message on Envelope" assert envelope.context.uri_raw is not None
def handle(self, message: Message) -> None: """ Implement the reaction to a message. :param message: the message :return: None """ # convenience representations fipa_msg = cast(FipaMessage, message) msg_performative = FipaMessage.Performative( message.get("performative")) # recover dialogue dialogues = cast(Dialogues, self.context.dialogues) if dialogues.is_belonging_to_registered_dialogue( fipa_msg, self.context.agent_address): dialogue = cast( Dialogue, dialogues.get_dialogue(fipa_msg, self.context.agent_address)) dialogue.incoming_extend(fipa_msg) else: self._handle_unidentified_dialogue(fipa_msg) return # handle message if msg_performative == FipaMessage.Performative.PROPOSE: self._handle_propose(fipa_msg, dialogue) elif msg_performative == FipaMessage.Performative.DECLINE: self._handle_decline(fipa_msg, dialogue) elif msg_performative == FipaMessage.Performative.MATCH_ACCEPT_W_INFORM: self._handle_match_accept(fipa_msg, dialogue) elif msg_performative == FipaMessage.Performative.INFORM: self._handle_inform(fipa_msg, dialogue)
def get_dialogue(self, fipa_msg: Message, sender: Address, agent_pbk: Address) -> Dialogue: """ Retrieve dialogue. :param fipa_msg: the fipa message :param sender_pbk: the sender public key :param agent_pbk: the public key of the agent :return: the dialogue """ fipa_msg = cast(FIPAMessage, fipa_msg) dialogue_reference = cast(Tuple[str, str], fipa_msg.get("dialogue_reference")) self_initiated_dialogue_label = DialogueLabel(dialogue_reference, sender, agent_pbk) other_initiated_dialogue_label = DialogueLabel(dialogue_reference, sender, sender) if other_initiated_dialogue_label in self.dialogues: other_initiated_dialogue = cast( FIPADialogue, self.dialogues[other_initiated_dialogue_label]) if other_initiated_dialogue.is_valid_next_message(fipa_msg): result = other_initiated_dialogue if self_initiated_dialogue_label in self.dialogues: self_initiated_dialogue = cast( FIPADialogue, self.dialogues[self_initiated_dialogue_label]) if self_initiated_dialogue.is_valid_next_message(fipa_msg): result = self_initiated_dialogue if result is None: raise ValueError('Should have found dialogue.') return result
def update(self, message: Message) -> bool: """ Extend the list of incoming/outgoing messages with 'message', if 'message' is valid. :param message: a message to be added :return: True if message successfully added, false otherwise """ if (message.is_incoming and self.last_message is not None and self.last_message.message_id == self.STARTING_MESSAGE_ID and self.dialogue_label.dialogue_reference[1] == self.OPPONENT_STARTER_REFERENCE): self._update_self_initiated_dialogue_label_on_second_message( message) counterparty = None # type: Optional[str] try: counterparty = message.counterparty except AssertionError: message.counterparty = self.dialogue_label.dialogue_opponent_addr if counterparty is not None: assert ( message.counterparty == self.dialogue_label.dialogue_opponent_addr ), "The counterparty specified in the message is different from the opponent in this dialogue." is_extendable = self.is_valid_next_message(message) if is_extendable: if message.is_incoming: self._incoming_messages.extend([message]) else: self._outgoing_messages.extend([message]) return is_extendable
def _update_self_initiated_dialogue_label_on_second_message( self, second_message: Message ) -> None: """ Update this (self initiated) dialogue's dialogue_label with a complete dialogue reference from counterparty's first message :param second_message: The second message in the dialogue (the first by the counterparty) :return: None """ dialogue_reference = cast( Tuple[str, str], second_message.get("dialogue_reference") ) self_initiated_dialogue_reference = (dialogue_reference[0], "") self_initiated_dialogue_label = DialogueLabel( self_initiated_dialogue_reference, second_message.counterparty, self.agent_address, ) if not self.is_empty: message_id = second_message.message_id if ( self.dialogue_label == self_initiated_dialogue_label and self.last_message.message_id == 1 # type: ignore and message_id == 2 and second_message.is_incoming ): updated_dialogue_label = DialogueLabel( dialogue_reference, self_initiated_dialogue_label.dialogue_opponent_addr, self_initiated_dialogue_label.dialogue_starter_addr, ) self._dialogue_label = updated_dialogue_label
def test_envelope_initialisation(): """Testing the envelope initialisation.""" msg = Message(content='hello') message_bytes = ProtobufSerializer().encode(msg) assert Envelope(to="Agent1", sender="Agent0", protocol_id="my_own_protocol", message=message_bytes), "Cannot generate a new envelope" envelope = Envelope(to="Agent1", sender="Agent0", protocol_id="my_own_protocol", message=message_bytes) envelope.to = "ChangedAgent" envelope.sender = "ChangedSender" envelope.protocol_id = "my_changed_protocol" envelope.message = b"HelloWorld" assert envelope.to == "ChangedAgent", "Cannot set to value on Envelope" assert envelope.sender == "ChangedSender",\ "Cannot set sender value on Envelope" assert envelope.protocol_id == "my_changed_protocol",\ "Cannot set protocol_id on Envelope " assert envelope.message == b"HelloWorld", "Cannot set message on Envelope"
def _update_self_initiated_dialogue_label_on_second_message( self, second_message: Message ) -> None: """ Update a self initiated dialogue label with a complete dialogue reference from counterparty's first message :param second_message: The second message in the dialogue (the first by the counterparty in a self initiated dialogue) :return: None """ dialogue_reference = cast( Tuple[str, str], second_message.get("dialogue_reference") ) self_initiated_dialogue_reference = (dialogue_reference[0], "") self_initiated_dialogue_label = DialogueLabel( self_initiated_dialogue_reference, second_message.counterparty, self.agent_address, ) if self_initiated_dialogue_label in self.dialogues: self_initiated_dialogue = self.dialogues[self_initiated_dialogue_label] self.dialogues.pop(self_initiated_dialogue_label) final_dialogue_label = DialogueLabel( dialogue_reference, self_initiated_dialogue_label.dialogue_opponent_addr, self_initiated_dialogue_label.dialogue_starter_addr, ) self_initiated_dialogue._dialogue_label = final_dialogue_label assert self_initiated_dialogue.dialogue_label not in self.dialogues self.dialogues.update( {self_initiated_dialogue.dialogue_label: self_initiated_dialogue} )
def _get_dialogue(self, message: Message) -> Optional[Dialogue]: """ Retrieve the dialogue 'message' belongs to. :param message: a message :return: the dialogue, or None in case such a dialogue does not exist """ dialogue_reference = cast(Tuple[str, str], message.get("dialogue_reference")) counterparty = message.counterparty self_initiated_dialogue_label = DialogueLabel( dialogue_reference, counterparty, self.agent_address ) other_initiated_dialogue_label = DialogueLabel( dialogue_reference, counterparty, counterparty ) if other_initiated_dialogue_label in self.dialogues: result = self.dialogues[ other_initiated_dialogue_label ] # type: Optional[Dialogue] elif self_initiated_dialogue_label in self.dialogues: result = self.dialogues[self_initiated_dialogue_label] else: result = None return result
def test_inbox_nowait(): """Tests the inbox without waiting.""" agent_address = "Agent0" receiver_address = "Agent1" msg = Message(content="hello") msg.counterparty = receiver_address multiplexer = Multiplexer([_make_dummy_connection()]) envelope = Envelope( to=receiver_address, sender=agent_address, protocol_id=UNKNOWN_PROTOCOL_PUBLIC_ID, message=msg, ) multiplexer.in_queue.put(envelope) inbox = InBox(multiplexer) assert (inbox.get_nowait() == envelope ), "Check for a message on the in queue and wait for no time."
def test_performative(self): """Test message performative.""" class SomePerformative(Message.Performative): value = "value" message = Message(performative=SomePerformative.value) assert message.performative == SomePerformative.value assert str(message.performative) == "value"
def encode(self, msg: Message) -> bytes: """Encode a 'default' message into bytes.""" body = {} # Dict[str, Any] msg_type = DefaultMessage.Type(msg.get("type")) body["type"] = str(msg_type.value) if msg_type == DefaultMessage.Type.BYTES: content = cast(bytes, msg.get("content")) body["content"] = base64.b64encode(content).decode("utf-8") elif msg_type == DefaultMessage.Type.ERROR: body["error_code"] = cast(str, msg.get("error_code")) body["error_msg"] = cast(str, msg.get("error_msg")) body["error_data"] = cast(str, msg.get("error_data")) else: raise ValueError("Type not recognized.") bytes_msg = json.dumps(body).encode("utf-8") return bytes_msg
def test_inbox_get(): """Tests for a envelope on the in queue.""" agent_address = "Agent0" receiver_address = "Agent1" msg = Message(content="hello") msg.counterparty = receiver_address multiplexer = Multiplexer([_make_dummy_connection()]) envelope = Envelope( to=receiver_address, sender=agent_address, protocol_id=UNKNOWN_PROTOCOL_PUBLIC_ID, message=msg, ) multiplexer.in_queue.put(envelope) inbox = InBox(multiplexer) assert ( inbox.get() == envelope ), "Checks if the returned envelope is the same with the queued envelope."
def get_dialogue(self, fipa_msg: Message, sender: Address, agent_pbk: Address) -> Dialogue: """ Retrieve dialogue. :param fipa_msg: the fipa message :param sender_pbk: the sender public key :param agent_pbk: the public key of the agent :return: the dialogue """ dialogue_id = cast(int, fipa_msg.get("dialogue_id")) opponent = sender target = cast(int, fipa_msg.get("target")) performative = fipa_msg.get("performative") self_initiated_dialogue_label = DialogueLabel(dialogue_id, opponent, agent_pbk) other_initiated_dialogue_label = DialogueLabel(dialogue_id, opponent, opponent) if performative == FIPAMessage.Performative.PROPOSE and target == PROPOSE_TARGET and self_initiated_dialogue_label in self.dialogues: dialogue = self.dialogues[self_initiated_dialogue_label] elif performative == FIPAMessage.Performative.ACCEPT: if target == ACCEPT_TARGET and other_initiated_dialogue_label in self.dialogues: dialogue = self.dialogues[other_initiated_dialogue_label] else: raise ValueError('Should have found dialogue.') elif performative == FIPAMessage.Performative.MATCH_ACCEPT: if target == MATCH_ACCEPT_TARGET and self_initiated_dialogue_label in self.dialogues: dialogue = self.dialogues[self_initiated_dialogue_label] else: raise ValueError('Should have found dialogue.') elif performative == FIPAMessage.Performative.DECLINE: if target == DECLINED_CFP_TARGET and self_initiated_dialogue_label in self.dialogues: dialogue = self.dialogues[self_initiated_dialogue_label] elif target == DECLINED_PROPOSE_TARGET and other_initiated_dialogue_label in self.dialogues: dialogue = self.dialogues[other_initiated_dialogue_label] elif target == DECLINED_ACCEPT_TARGET and self_initiated_dialogue_label in self.dialogues: dialogue = self.dialogues[self_initiated_dialogue_label] else: raise ValueError('Should have found dialogue.') else: raise ValueError('Should have found dialogue.') dialogue = cast(Dialogue, dialogue) return dialogue
def dummy_envelope( cls, to: str = "test", sender: str = "test", protocol_id: PublicId = DefaultMessage.protocol_id, message: Message = None, ) -> Envelope: """ Create envelope, if message is not passed use .dummy_message method. :return: Envelope """ message = message or cls.dummy_default_message() message.sender = sender message.to = to return Envelope( to=to, sender=sender, protocol_id=protocol_id, message=message, )
def handle(self, message: Message) -> None: """ Implement the reaction to a message. :param message: the message :return: None """ self.dialogue.update(message) self.handled_message = message message.counterparty = self.dialogue.dialogue_label.dialogue_opponent_addr self.dialogue.update(self.message_2) self.context.outbox.put_message(self.message_2)
def test_inbox_nowait(): """Tests the inbox without waiting.""" msg = Message(content="hello") message_bytes = ProtobufSerializer().encode(msg) multiplexer = Multiplexer([DummyConnection()]) envelope = Envelope(to="Agent1", sender="Agent0", protocol_id="my_own_protocol", message=message_bytes) multiplexer.in_queue.put(envelope) inbox = InBox(multiplexer) assert inbox.get_nowait( ) == envelope, "Check for a message on the in queue and wait for no time."
def is_permitted_for_new_dialogue(self, fipa_msg: Message, sender: Address) -> bool: """ Check whether a fipa message is permitted for a new dialogue. That is, the message has to - be a CFP, and - have the correct msg id and message target. :param message: the fipa message :param sender: the sender :return: a boolean indicating whether the message is permitted for a new dialogue """ fipa_msg = cast(FIPAMessage, fipa_msg) msg_id = fipa_msg.get("id") target = fipa_msg.get("target") performative = fipa_msg.get("performative") result = performative == FIPAMessage.Performative.CFP \ and msg_id == STARTING_MESSAGE_ID \ and target == STARTING_MESSAGE_TARGET return result
def is_belonging_to_registered_dialogue(self, fipa_msg: Message, sender: Address, agent_pbk: Address) -> bool: """ Check whether an agent message is part of a registered dialogue. :param fipa_msg: the fipa message :param sender: the sender :param agent_pbk: the public key of the agent :return: boolean indicating whether the message belongs to a registered dialogue """ dialogue_id = cast(int, fipa_msg.get("dialogue_id")) opponent = sender target = cast(int, fipa_msg.get("target")) performative = fipa_msg.get("performative") self_initiated_dialogue_label = DialogueLabel(dialogue_id, opponent, agent_pbk) other_initiated_dialogue_label = DialogueLabel(dialogue_id, opponent, opponent) result = False if performative == FIPAMessage.Performative.PROPOSE and target == PROPOSE_TARGET and self_initiated_dialogue_label in self.dialogues: self_initiated_dialogue = cast(Dialogue, self.dialogues[self_initiated_dialogue_label]) result = self_initiated_dialogue.is_expecting_propose() elif performative == FIPAMessage.Performative.ACCEPT: if target == ACCEPT_TARGET and other_initiated_dialogue_label in self.dialogues: other_initiated_dialogue = cast(Dialogue, self.dialogues[other_initiated_dialogue_label]) result = other_initiated_dialogue.is_expecting_initial_accept() elif performative == FIPAMessage.Performative.MATCH_ACCEPT: if target == MATCH_ACCEPT_TARGET and self_initiated_dialogue_label in self.dialogues: self_initiated_dialogue = cast(Dialogue, self.dialogues[self_initiated_dialogue_label]) result = self_initiated_dialogue.is_expecting_matching_accept() elif performative == FIPAMessage.Performative.DECLINE: if target == DECLINED_CFP_TARGET and self_initiated_dialogue_label in self.dialogues: self_initiated_dialogue = cast(Dialogue, self.dialogues[self_initiated_dialogue_label]) result = self_initiated_dialogue.is_expecting_cfp_decline() elif target == DECLINED_PROPOSE_TARGET and other_initiated_dialogue_label in self.dialogues: other_initiated_dialogue = cast(Dialogue, self.dialogues[other_initiated_dialogue_label]) result = other_initiated_dialogue.is_expecting_propose_decline() elif target == DECLINED_ACCEPT_TARGET and self_initiated_dialogue_label in self.dialogues: self_initiated_dialogue = cast(Dialogue, self.dialogues[self_initiated_dialogue_label]) result = self_initiated_dialogue.is_expecting_accept_decline() return result
def update(self, message: Message) -> Optional[Dialogue]: """ Update the state of dialogues with a new incoming message. If the message is for a new dialogue, a new dialogue is created with 'message' as its first message, and returned. If the message is addressed to an existing dialogue, the dialogue is retrieved, extended with this message and returned. If there are any errors, e.g. the message dialogue reference does not exists or the message is invalid w.r.t. the dialogue, return None. :param message: a new message :return: the new or existing dialogue the message is intended for, or None in case of any errors. """ dialogue_reference = message.dialogue_reference if ( # new dialogue by other dialogue_reference[0] != "" and dialogue_reference[1] == "" and message.is_incoming): dialogue = self._create_opponent_initiated( dialogue_opponent_addr=message.counterparty, dialogue_reference=dialogue_reference, role=self._role_from_first_message(message), ) # type: Optional[Dialogue] elif ( # new dialogue by self dialogue_reference[0] != "" and dialogue_reference[1] == "" and not message.is_incoming): assert ( message.counterparty is not None ), "The message counter-party field is not set {}".format(message) dialogue = self._create_self_initiated( dialogue_opponent_addr=message.counterparty, role=self._role_from_first_message(message), ) else: # existing dialogue self._update_self_initiated_dialogue_label_on_second_message( message) dialogue = self.get_dialogue(message) if dialogue is not None: if message.counterparty is None: message.counterparty = dialogue.dialogue_label.dialogue_opponent_addr else: assert ( message.counterparty == dialogue.dialogue_label.dialogue_opponent_addr ), "The counterparty specified in the message is different from the opponent in this dialogue." dialogue.update(message) result = dialogue # type: Optional[Dialogue] else: # couldn't find the dialogue result = None return result
def test_outbox_put(): """Tests that an envelope is putted into the queue.""" msg = Message(content="hello") message_bytes = ProtobufSerializer().encode(msg) my_queue = Queue() envelope = Envelope(to="Agent1", sender="Agent0", protocol_id="my_own_protocol", message=message_bytes) my_queue.put(envelope) _outbox = OutBox(my_queue) _outbox.put(envelope) assert _outbox.empty() is False,\ "Oubox must not be empty after putting an envelope"
def test_inbox_get(): """Tests for a envelope on the in queue.""" msg = Message(content="hello") message_bytes = ProtobufSerializer().encode(msg) multiplexer = Multiplexer([DummyConnection()]) envelope = Envelope(to="Agent1", sender="Agent0", protocol_id="my_own_protocol", message=message_bytes) multiplexer.in_queue.put(envelope) inbox = InBox(multiplexer) assert inbox.get( ) == envelope, "Checks if the returned envelope is the same with the queued envelope."