def test_body_with_languages(): msg = aioxmpp.Message(type_=aioxmpp.MessageType.CHAT) msg.body["en"] = "Hello World" msg.body["es"] = "Hola Mundo" new_msg = Message.from_node(msg) assert new_msg.body == "Hello World"
async def send_party_message(self, content: str) -> None: if self.muc_room is None: raise PartyError('Can\'t send message. Reason: No party found') msg = aioxmpp.Message(type_=aioxmpp.MessageType.GROUPCHAT) msg.body[None] = content self.muc_room.send_message(msg)
async def send_message(self, message): if not self.connected: await self.connect() msg = aioxmpp.Message( type_=aioxmpp.MessageType.NORMAL ) payload = FCMMessage() payload_body = message.as_dict() payload.text = json.dumps(payload_body) msg.fcm_payload = payload future_response = asyncio.Future() self.requests[message.message_id] = future_response self.refresh_inactivity_timer() try: await self.xmpp_client.stream.send(msg) except Exception: self.requests.pop(message.message_id) raise response = await future_response return response
def test_leave_non_protocol_messages_intact(self): stanza = aioxmpp.Message( aioxmpp.MessageType.NORMAL, from_=TEST_JID1, to=TEST_FROM, ) self.assertIs(self.s._handle_message(stanza), stanza)
def test_send_with_attached_tracker(self): msg_delivered = asyncio.Event() def state_change_cb(new_state, *args): if (new_state == aioxmpp.tracking.MessageState.DELIVERED_TO_RECIPIENT): msg_delivered.set() msg = aioxmpp.Message(type_=aioxmpp.MessageType.CHAT, to=self.b.local_jid) msg.body[LANG] = "This is a non-colourful test message!" tracker = self.a_mdr.attach_tracker(msg) tracker.on_state_changed.connect(state_change_cb) msg_recvd = asyncio.Future() def cb(message): msg_recvd.set_result(message) self.b_recv.register_callback(aioxmpp.MessageType.CHAT, None, cb) yield from self.a.send(msg) msg_b = yield from msg_recvd self.assertDictEqual(msg_b.body, {LANG: "This is a non-colourful test message!"}) self.assertTrue(msg_b.xep0184_request_receipt) self.assertFalse(msg_delivered.is_set()) response = aioxmpp.mdr.compose_receipt(msg_b) yield from self.b.send(response) yield from msg_delivered.wait()
def test_forward_normal_even_without_body_to_existing(self): msg = aioxmpp.Message( type_=aioxmpp.MessageType.NORMAL, from_=PEER_JID.replace(resource="foo"), ) msg.body[None] = "foo" conv = self.s.get_conversation(PEER_JID.bare()) with contextlib.ExitStack() as stack: _handle_message = stack.enter_context( unittest.mock.patch.object( conv, "_handle_message", )) self.assertIsNone( self.s._filter_message( msg, msg.from_, False, im_dispatcher.MessageSource.STREAM, )) _handle_message.assert_called_once_with( msg, msg.from_, False, im_dispatcher.MessageSource.STREAM, )
def test_message_from_node(): aiomsg = aioxmpp.Message(type_=aioxmpp.MessageType.CHAT) data = forms_xso.Data(type_=forms_xso.DataType.FORM) data.fields.append( forms_xso.Field( var="performative", type_=forms_xso.FieldType.TEXT_SINGLE, values=["request"], ) ) data.fields.append( forms_xso.Field( var="_thread_node", type_=forms_xso.FieldType.TEXT_SINGLE, values=["thread-id"], ) ) data.title = SPADE_X_METADATA aiomsg.xep0004_data = [data] msg = Message.from_node(aiomsg) assert msg.thread == "thread-id" assert msg.get_metadata("performative") == "request" assert msg.metadata == {"performative": "request"}
def sendMsg(self,data): msgData = aioxmpp.Message( to=data['JID'], # recipient_jid must be an aioxmpp.JID type_=aioxmpp.MessageType.GROUPCHAT, ) msgData.body[None] = data['msg'] self.roomList[str(data['JID'])]['room'].send_message(msgData)
async def test_message_from_a_to_b(self): a = await self.provisioner.get_connected_client() b = await self.provisioner.get_connected_client() fut = asyncio.Future() def cb(msg): fut.set_result(msg) with aioxmpp.stream.message_handler(b.stream, aioxmpp.MessageType.CHAT, a.local_jid, cb): msg_sent = aioxmpp.Message( to=b.local_jid, type_=aioxmpp.MessageType.CHAT, ) msg_sent.body[aioxmpp.structs.LanguageTag.fromstr("en")] = \ "Hello World!" await a.send(msg_sent) msg_rcvd = await fut self.assertEqual( msg_rcvd.body[aioxmpp.structs.LanguageTag.fromstr("en")], "Hello World!")
async def bridge(self, client, message, *, edited=False): """Take a discord message and send it over to the MUC.""" room = discord.utils.find( lambda room: room["channel_id"] == message.channel.id, self.config["rooms"]) if not room or room.get("disabled", False): return if room.get("discord_log", False): content = extract_message_content(message) log.info("[discord] <%s> %s", message.author, content) reply = aioxmpp.Message( type_=aioxmpp.MessageType.GROUPCHAT, to=aioxmpp.JID.fromstr(room["jid"]), ) formatted_content = await format_discord_message(client, message) if edited: formatted_content += " (edited)" reply.body[None] = formatted_content await self.client.send(reply)
def construct_message(to, body): msg = aioxmpp.Message( to=aioxmpp.JID.fromstr(to), # recipient_jid must be an aioxmpp.JID type_=aioxmpp.MessageType.CHAT, ) # None is for "default language" msg.body[None] = body return msg
def sendMsg(self, data): msg = aioxmpp.Message( to=data['JID'], type_=aioxmpp.MessageType.CHAT, ) msg.body[None] = data['msg'] self.conversationList[str( data['JID'])]['conversation'].send_message(msg)
def setup(self): self.web.start(templates_path="examples") template1 = Template(sender="agent0@fake_server") template2 = Template(sender="agent1@fake_server") template3 = Template(sender="agent2@fake_server") template4 = Template(sender="agent3@fake_server") # Create some dummy behaviours dummybehav = self.DummyBehav() self.add_behaviour(dummybehav, template=template1) periodbehav = self.DummyPeriodBehav(period=12.7) self.add_behaviour(periodbehav, template=template2) timeoutbehav = self.DummyTimeoutBehav(start_at=datetime.datetime.now()) self.add_behaviour(timeoutbehav, template=template3) fsm_behav = self.DummyFSMBehav() self.add_behaviour(fsm_behav, template=template4) behavs = [dummybehav, periodbehav, timeoutbehav, fsm_behav] # Create some fake contacts self.add_fake_contact("agent0@fake_server", PresenceType.AVAILABLE) self.add_fake_contact("agent1@fake_server", PresenceType.AVAILABLE, show=PresenceShow.AWAY) self.add_fake_contact( "agent2@fake_server", PresenceType.AVAILABLE, show=PresenceShow.DO_NOT_DISTURB, ) self.add_fake_contact("agent3@fake_server", PresenceType.UNAVAILABLE) self.add_fake_contact("agent4@fake_server", PresenceType.AVAILABLE, show=PresenceShow.CHAT) self.add_fake_contact("agent5@fake_server", PresenceType.UNAVAILABLE) # Send and Receive some fake messages self.traces.reset() for i in range(20): number = random.randint(0, 3) from_ = JID.fromstr("agent{}@fake_server".format(number)) msg = aioxmpp.Message(from_=from_, to=self.jid, type_=MessageType.CHAT) msg.body[None] = "Hello from {}! This is a long message.".format( from_.localpart) msg = Message.from_node(msg) msg.metadata = { "performative": "inform", "acl-representation": "xml" } msg = msg.prepare() self._message_received(msg=msg) msg = Message(sender=str(self.jid), to=str(from_), body="This is my answer.") msg.sent = True self.traces.append(msg, category=str(behavs[number]))
async def send_friend_message(self, jid, content): if self.stream is None: raise XMPPError('xmpp is not connected') msg = aioxmpp.Message( to=jid, type_=aioxmpp.MessageType.CHAT, ) msg.body[None] = content await self.stream.send(msg)
async def test_send_message_from_user2_to_nonexisting(client): recipient_jid = aioxmpp.JID.fromstr("nonexisting@localhost") async with client.connected() as stream: msg = aioxmpp.Message( to=recipient_jid, type_=aioxmpp.MessageType.CHAT, ) msg.body[None] = "Hello World!" await client.send(msg)
async def test_can_not_log_in_with_wrong_password(client): with pytest.raises(aiosasl.AuthenticationFailure): recipient_jid = aioxmpp.JID.fromstr("nonexisting@localhost") async with client.connected() as stream: msg = aioxmpp.Message( to=recipient_jid, type_=aioxmpp.MessageType.CHAT, ) msg.body[None] = "Hello World!" await client.send(msg)
async def test_send_message_from_admin_to_user1(client): recipient_jid = aioxmpp.JID.fromstr("user1@localhost") async with client.connected() as stream: msg = aioxmpp.Message( to=recipient_jid, type_=aioxmpp.MessageType.CHAT, ) # None is for "default language" msg.body[None] = "Hello World!" await client.send(msg)
async def _send_message(from_jid, from_passwd, to_jid, message): client = aioxmpp.PresenceManagedClient( aioxmpp.JID.fromstr(from_jid), aioxmpp.make_security_layer(from_passwd), ) msg = aioxmpp.Message( to=aioxmpp.JID.fromstr(to_jid), type_=aioxmpp.MessageType.CHAT, ) msg.body[None] = message async with client.connected(): await client.send(msg)
def send_update(self, jid, event): msg = aioxmpp.Message( to=jid, type_=aioxmpp.MessageType.CHAT, ) msg.body[None] = '\n'.join( filter(None, [ strip_html(deref_multi(event['info'][0], x) or '') for x in (['headline'], ['description'], ['instruction'], ['area', 0, 'areaDesc'], ['effective'], ['expires']) ])) self.client.enqueue(msg)
async def main(from_jid, to_jid, password, message): client = aioxmpp.PresenceManagedClient( aioxmpp.JID.fromstr(from_jid), aioxmpp.make_security_layer(password), ) async with client.connected() as stream: msg = aioxmpp.Message( to=aioxmpp.JID.fromstr(to_jid), type_=aioxmpp.MessageType.CHAT, ) msg.body[None] = message await stream.send(msg)
def test_autocreate_with_fulljid_if_muc_tagged(self): msg = aioxmpp.Message( type_=aioxmpp.MessageType.CHAT, from_=PEER_JID.replace(resource="foo"), ) msg.body[None] = "foo" msg.xep0045_muc_user = muc_xso.UserExt() with contextlib.ExitStack() as stack: Conversation = stack.enter_context(unittest.mock.patch( "aioxmpp.im.p2p.Conversation", )) self.assertIsNone(self.s._filter_message( msg, PEER_JID.replace(localpart="fnord", resource="foo"), False, im_dispatcher.MessageSource.STREAM, )) Conversation.assert_called_once_with( self.s, PEER_JID.replace(localpart="fnord", resource="foo"), parent=None ) c = self.s.get_conversation( PEER_JID.replace(localpart="fnord", resource="foo") ) Conversation.assert_called_once_with( self.s, PEER_JID.replace(localpart="fnord", resource="foo"), parent=None ) self.assertEqual(c, Conversation()) self.listener.on_conversation_new.assert_called_once_with( Conversation() ) self.listener.on_spontaneous_conversation.assert_called_once_with( Conversation() ) Conversation()._handle_message.assert_called_once_with( msg, PEER_JID.replace(localpart="fnord", resource="foo"), False, im_dispatcher.MessageSource.STREAM, )
async def run(self): """ Run the program. That means connecting, then sending a message to the account that can send text to this buffer, signaling that this buffer is now available. After that an infinite loop is started so the program can receive messages. This loop can be broken when self.running is set to false. """ async with self.client.connected() as stream: msg = aioxmpp.Message(to=aioxmpp.JID.fromstr(self.receive_from), type_=aioxmpp.MessageType.CHAT) msg.body[None] = "Ready to receive now!" await self.client.send(msg) while self.running: await asyncio.sleep(10) msg = aioxmpp.Message(to=aioxmpp.JID.fromstr(self.receive_from), type_=aioxmpp.MessageType.CHAT) msg.body[None] = "Shutting down!" await self.client.send(msg) sys.exit(0)
async def test_exception_from_non_wellformed(self): c = await self.provisioner.get_connected_client() msg = aioxmpp.Message( to=c.local_jid, type_=aioxmpp.MessageType.NORMAL, ) msg.body[None] = "foo\u0000" with self.assertRaisesRegex(ValueError, "not allowed"): await c.send(msg) msg.body[None] = "foo" await c.send(msg)
def message_received(msg): if not msg.body: # do not reflect anything without a body return # we could also use reply = msg.make_reply() instead reply = aioxmpp.Message( type_=msg.type_, to=msg.from_, ) # make_reply() would not set the body though reply.body.update(msg.body) client.enqueue(reply)
async def async_send_messages(self, messages): client = aioxmpp.Client( self.g_jid, self.g_security_layer, ) client.resumption_timeout = 0 async with client.connected() as stream: for message_content in messages: msg = aioxmpp.Message( to=self.to_jid, type_=aioxmpp.MessageType.CHAT, ) msg.body[None] = message_content await stream.send(msg)
def _send_message(self): body = self.ui.message_input.toPlainText() msg = aioxmpp.Message(type_=aioxmpp.MessageType.CHAT) msg.body[None] = body msg.xep0333_markable = True url_match = self.URL_RE.match(body) if url_match is not None: info = url_match.groupdict() url = info.get("url_name", info.get("url_nonword", info.get("url_paren"))) if url: msg.xep0066_oob = aioxmpp.misc.OOBExtension() msg.xep0066_oob.url = url self.ui.message_input.clear() yield from self._send_message_stanza(msg)
def test_receive_without_behaviours(): agent = make_connected_agent() aiomsg = aioxmpp.Message(type_=aioxmpp.MessageType.CHAT) msg = Message.from_node(aiomsg) assert agent.traces.len() == 0 agent.start(auto_register=False) with LogCapture() as log: agent._message_received(aiomsg) log.check_present(('spade.Agent', 'WARNING', f"No behaviour matched for message: {msg}")) assert agent.traces.len() == 1 assert msg in agent.traces.store[0] agent.stop()
def test_autocreate_conversation_from_recvd_normal_with_body(self): msg = aioxmpp.Message( type_=aioxmpp.MessageType.NORMAL, from_=PEER_JID.replace(resource="foo"), ) msg.body[None] = "foo" with contextlib.ExitStack() as stack: Conversation = stack.enter_context(unittest.mock.patch( "aioxmpp.im.p2p.Conversation", )) self.assertIsNone(self.s._filter_message( msg, msg.from_, False, im_dispatcher.MessageSource.STREAM, )) Conversation.assert_called_once_with( self.s, msg.from_.bare(), parent=None ) c = self.s.get_conversation(PEER_JID) Conversation.assert_called_once_with( self.s, msg.from_.bare(), parent=None ) self.assertEqual(c, Conversation()) self.listener.on_conversation_new.assert_called_once_with( Conversation() ) self.listener.on_spontaneous_conversation.assert_called_once_with( Conversation() ) Conversation()._handle_message.assert_called_once_with( msg, msg.from_, False, im_dispatcher.MessageSource.STREAM, )
async def send_ack(self, device_token, message_id): if not self.connected: await self.connect() msg = aioxmpp.Message(type_=aioxmpp.MessageType.NORMAL) payload = FCMMessage() payload_body = { "to": str(device_token), "message_id": str(message_id), "message_type": "ack" } payload.text = json.dumps(payload_body) msg.fcm_payload = payload self.refresh_inactivity_timer() await self.xmpp_client.stream.send(msg)
def test_converse_with_preexisting(self): c1 = yield from self.firstwitch.summon(p2p.Service).get_conversation( self.secondwitch.local_jid.bare() ) c2 = yield from self.secondwitch.summon(p2p.Service).get_conversation( self.firstwitch.local_jid.bare() ) fwmsgs = [] fwev = asyncio.Event() def fwevset(message, member, source): if member == c1.me: return fwmsgs.append(message) fwev.set() swmsgs = [] swev = asyncio.Event() def swevset(message, member, source): if member == c2.me: return swmsgs.append(message) swev.set() c1.on_message.connect(fwevset) c2.on_message.connect(swevset) msg = aioxmpp.Message(aioxmpp.MessageType.CHAT) msg.body[None] = "foo" yield from c1.send_message(msg) yield from swev.wait() self.assertEqual(len(swmsgs), 1) self.assertEqual(swmsgs[0].body[None], "foo") self.assertEqual(len(fwmsgs), 0) msg.body[None] = "bar" yield from c2.send_message(msg) yield from fwev.wait() self.assertEqual(len(fwmsgs), 1) self.assertEqual(fwmsgs[0].body[None], "bar") self.assertEqual(len(swmsgs), 1)