def testJIDaliases(self):
"""Test changing JID using aliases for domain."""
j = JID('user@someserver/resource')
j.server = 'anotherserver'
self.check_jid(j, domain='anotherserver')
j.host = 'yetanother'
self.check_jid(j, domain='yetanother')
def zulip_to_jid(email, jabber_domain):
jid = JID(email, domain=jabber_domain)
if (options.zulip_email_suffix
and options.zulip_email_suffix in jid.username
and not jid.username.endswith("-bot")):
jid.username = jid.username.rpartition(options.zulip_email_suffix)[0]
return jid
def testJIDUnescape(self):
jid = JID(local='here\'s_a_wild_&_/cr%zy/_address_for:<wv>("IMPS")',
domain='example.com')
ujid = jid.unescape()
self.assertEqual(ujid.local, 'here\'s_a_wild_&_/cr%zy/_address_for:<wv>("IMPS")')
jid = JID(local='blah\\foo\\20bar', domain='example.com')
ujid = jid.unescape()
self.assertEqual(ujid.local, 'blah\\foo\\20bar')
def testJIDSetFullWithUser(self):
"""Test setting the full JID with a user portion."""
j = JID('user@domain/resource')
j.full = 'otheruser@otherdomain/otherresource'
self.check_jid(j,
'otheruser',
'otherdomain',
'otherresource',
'otheruser@otherdomain',
'otheruser@otherdomain/otherresource',
'otheruser@otherdomain/otherresource')
def testJIDBareNoUser(self):
"""Test setting the bare JID without a user."""
j = JID('user@domain/resource')
j.bare = 'otherdomain'
self.check_jid(j,
'',
'otherdomain',
'resource',
'otherdomain',
'otherdomain/resource',
'otherdomain/resource')
def testJIDchange(self):
"""Test changing JID of the form 'user@server/resource/with/slashes'"""
j = JID('user1@someserver1/some1/resource1')
j.user = '******'
j.domain = 'someserver'
j.resource = 'some/resource'
self.check_jid(j,
'user',
'someserver',
'some/resource',
'user@someserver',
'user@someserver/some/resource',
'user@someserver/some/resource')
def testJIDFullNoUserNoResource(self):
"""
Test setting the full JID without a user
portion and without a resource.
"""
j = JID('user@domain/resource')
j.full = 'otherdomain'
self.check_jid(j,
'',
'otherdomain',
'',
'otherdomain',
'otherdomain',
'otherdomain')
def stream_message(self, msg):
# type: (Dict[str, str]) -> None
assert (self.jabber is not None)
stream = msg['display_recipient']
if not stream.endswith("/xmpp"):
return
room = stream_to_room(stream)
jabber_recipient = JID(local=room, domain=options.conference_domain)
outgoing = self.jabber.make_message(mto=jabber_recipient,
mbody=msg['content'],
mtype='groupchat')
outgoing['thread'] = u'\u1FFFE'
outgoing.send()
def testJIDUnescape(self):
jid = JID(local='here\'s_a_wild_&_/cr%zy/_address_for:<wv>("IMPS")',
domain='example.com')
ujid = jid.unescape()
self.assertEqual(ujid.local, 'here\'s_a_wild_&_/cr%zy/_address_for:<wv>("IMPS")')
jid = JID(local='blah\\foo\\20bar', domain='example.com')
ujid = jid.unescape()
self.assertEqual(ujid.local, 'blah\\foo\\20bar')
def __init__(self, jid: JID, password: str, rooms: List[str]) -> None:
if jid.resource:
self.nick = jid.resource
else:
self.nick = jid.username
jid.resource = "zulip"
ClientXMPP.__init__(self, jid, password)
self.rooms = set() # type: Set[str]
self.rooms_to_join = rooms
self.add_event_handler("session_start", self.session_start)
self.add_event_handler("message", self.message)
self.zulip = None
self.use_ipv6 = False
self.register_plugin('xep_0045') # Jabber chatrooms
self.register_plugin('xep_0199') # XMPP Ping
def create_rooms(self, rooms, callback=None):
"""
Creates or joins the given rooms
:param rooms: A list of rooms to join / create
:param callback: Method to call back when all rooms have been created
:raise ValueError: No Multi-User Chat service available
"""
# Look for the MUC service if necessary
if not self.__muc_service:
try:
self.__muc_service = next(self.iter_services(FEATURE_MUC))
except StopIteration:
raise ValueError("No Multi-User Chat service on server")
if callback is not None:
# Prepare a callback
self.__countdowns.add(
_MarksCallback((JID(local=room, domain=self.__muc_service)
for room in rooms), callback))
# Prepare the room creator
creator = RoomCreator(self, "Herald-XMPP-RoomCreator")
# Prepare rooms configuration
rooms_config = {
# ... no max users limit
'muc#roomconfig_maxusers': '0',
# ... accepted members only
'muc#roomconfig_membersonly': '1',
# ... every participant can send invites
'muc#roomconfig_allowinvites': '1',
# ... room can disappear
'muc#roomconfig_persistentroom': '0',
# ... OpenFire: Forbid nick changes
'x-muc#roomconfig_canchangenick': '0'
}
# Create rooms
for room in rooms:
creator.create_room(room, self.__muc_service, self._nick,
rooms_config, self.__room_created,
self.__room_error)
def testtransport_presence_event_handler_with_no_status(self):
"""
Test to check the presence method with no valid status of the signal class.
"""
sig_dict, signal = self.setup_vars_mocks()
transport = XmppTransport.factory(
"1", sig_dict["Signal"]["Overlays"]["A0FB389"], signal,
signal._presence_publisher, None, None)
presence = {
"from": "raj",
"to": "raj@ipop",
"status": "ipop?#1234434323"
}
transport.boundjid = JID("raj@ipop/ipop")
jid_cache = Mock()
presence_publisher = Mock()
transport._presence_publisher = presence_publisher
transport._presence_publisher.post_update = MagicMock()
transport._jid_cache = jid_cache
transport._jid_cache.add_entry = MagicMock()
transport._sig.sig_log = MagicMock()
transport.presence_event_handler(presence)
transport._sig.sig_log.assert_called_once()
print("Passed : testtransport_presence_event_handler_with_uid")
def join_muc(self, room: str) -> None:
if room in self.rooms:
return
logging.debug("Joining " + room)
self.rooms.add(room)
muc_jid = JID(local=room, domain=options.conference_domain)
xep0045 = self.plugin['xep_0045']
try:
xep0045.joinMUC(muc_jid, self.nick, wait=True)
except InvalidJID:
logging.error("Could not join room: " + str(muc_jid))
return
# Configure the room. Really, we should only do this if the room is
# newly created.
form = None
try:
form = xep0045.getRoomConfig(muc_jid)
except ValueError:
pass
if form:
xep0045.configureRoom(muc_jid, form)
else:
logging.error("Could not configure room: " + str(muc_jid))
def testJIDFromFull(self):
"""Test using JID of the form 'user@server/resource/with/slashes'."""
self.check_jid(JID('user@someserver/some/resource'), 'user',
'someserver', 'some/resource', 'user@someserver',
'user@someserver/some/resource',
'user@someserver/some/resource')
def testJIDBareNoUser(self):
"""Test setting the bare JID without a user."""
j = JID('user@domain/resource')
j.bare = 'otherdomain'
self.check_jid(j, '', 'otherdomain', 'resource', 'otherdomain',
'otherdomain/resource', 'otherdomain/resource')
def testJIDNoResource(self):
"""Test using JID of the form 'user@domain'."""
self.check_jid(JID('user@someserver'), 'user', 'someserver', '',
'user@someserver', 'user@someserver', 'user@someserver')
def testJIDNoUser(self):
"""Test JID of the form 'component.domain.tld'."""
self.check_jid(JID('component.someserver'), '', 'component.someserver',
'', 'component.someserver', 'component.someserver',
'component.someserver')
def test1023LengthDomain(self):
domain = ('a.' * 509) + 'a.com'
jid1 = JID(domain=domain)
jid2 = JID('user@%s/resource' % domain)
def nickname_to_jid(self, room: str, nick: str) -> JID:
jid = self.plugin['xep_0045'].getJidProperty(room, nick, "jid")
if (jid is None or jid == ''):
return JID(local=nick.replace(' ', ''), domain=self.boundjid.domain)
else:
return jid
def __on_message(self, msg):
"""
An Herald Message received (fire & forget)
"""
if msg['delay']['stamp'] is not None:
# Delayed message: ignore
return
if msg['type'] in ('chat', 'normal'):
# Check message source
from_jid = msg['from']
if from_jid.bare == self.boundjid.bare:
# Loopback message
return
try:
content = msg['body'].split(':', 2)
if content[0] != 'invite':
# Not a request for invitation
self.__reply(msg, "Unhandled command: {0}", content[0])
return
try:
# Convert the key in an integer and look for it
if content[1] != "42":
key = int(content[1], 16)
self.__keys.remove(key)
except KeyError:
self.__reply(msg, "Unauthorized key")
except (TypeError, ValueError):
self.__reply(msg, "Invalid key")
else:
try:
# Authorized client: invite it to requested rooms
rooms = set(content[2].split(','))
except IndexError:
# No room specified
rooms = set()
# Also invite it in the main room, if any
if self.__main_room:
rooms.add(self.__main_room)
rooms_jids = set(
JID(local=room, domain=self.__muc_service)
for room in rooms)
def rooms_ready(successes, failures):
"""
Invites the requester in the rooms it requested, as
soon as they are ready
:param successes: JIDs of the usable rooms
:param failures: JIDs of the rooms which
failed
"""
for room_jid in rooms_jids.difference(failures):
# Invite to valid rooms (old and new ones)
self['xep_0045'].invite(room_jid, from_jid.full,
"Client accepted")
# Create rooms if necessary...
to_create = rooms.difference(self.__rooms)
if to_create:
# We'll have to wait for the rooms before inviting
# the sender
self.create_rooms(to_create, rooms_ready)
else:
# All rooms already exist
rooms_ready(rooms_jids, [])
except IndexError:
self.__reply(msg, "Bad command format")
def testJIDInequality(self):
jid1 = JID('user@domain/resource')
jid2 = JID('otheruser@domain/resource')
self.assertFalse(jid1 == jid2, "Same JIDs are not considered equal")
self.assertTrue(jid1 != jid2, "Same JIDs are considered not equal")
def testJIDEscape(self):
jid = JID(local='here\'s_a_wild_&_/cr%zy/_address_for:<wv>("IMPS")',
domain='example.com')
self.assertEqual(jid.local, r'here\27s_a_wild_\26_\2fcr%zy\2f_address_for\3a\3cwv\3e(\22IMPS\22)')
def test1023LengthLocalPart(self):
local = 'a' * 1023
jid1 = JID(local=local, domain='test.com')
jid2 = JID('*****@*****.**' % local)
def __init__(self, muc_jid, user_jid, presence_type, message):
self.muc_jid = JID(muc_jid)
self.user_jid = JID(user_jid)
self.presence_type = presence_type
self.message = message
def testDomainIPv4(self):
domain = '127.0.0.1'
jid1 = JID(domain=domain)
jid2 = JID('user@%s/resource' % domain)
def test1023LengthResource(self):
resource = 'r' * 1023
jid1 = JID(domain='test.com', resource=resource)
jid2 = JID('test.com/%s' % resource)
def testDomainIPv6(self):
domain = '[::1]'
jid1 = JID(domain=domain)
jid2 = JID('user@%s/resource' % domain)
def testJIDEquality(self):
"""Test that JIDs with the same content are equal."""
jid1 = JID('user@domain/resource')
jid2 = JID('user@domain/resource')
self.assertTrue(jid1 == jid2, "Same JIDs are not considered equal")
self.assertFalse(jid1 != jid2, "Same JIDs are considered not equal")
if options.mode not in ('public', 'personal'):
config_error(
"Bad value for --mode: must be one of 'public' or 'personal'")
if None in (options.jid, options.jabber_password):
config_error(
"You must specify your Jabber JID and Jabber password either "
"in the Zulip configuration file or on the commandline")
zulipToJabber = ZulipToJabberBot(
zulip.init_from_options(options, "JabberMirror/" + __version__))
# This won't work for open realms that don't have a consistent domain
options.zulip_domain = zulipToJabber.client.email.partition('@')[-1]
try:
jid = JID(options.jid)
except InvalidJID as e:
config_error("Bad JID: %s: %s" % (options.jid, e.message))
if options.conference_domain is None:
options.conference_domain = "conference.%s" % (jid.domain, )
xmpp = JabberToZulipBot(jid, options.jabber_password,
get_rooms(zulipToJabber))
address = None
if options.jabber_server_address:
address = (options.jabber_server_address, options.jabber_server_port)
if not xmpp.connect(use_tls=not options.no_use_tls, address=address):
sys.exit("Unable to connect to Jabber server")
def testJIDEscapeExistingSequences(self):
jid = JID(local='blah\\foo\\20bar', domain='example.com')
self.assertEqual(jid.local, 'blah\\foo\\5c20bar')
