david/jcl
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

correct JID used to respond to presence stanzas

Browse Source 
darcs-hash:20080528162241-86b55-352958d54119f17421d32b475bfe69438126d64d.gz
This commit is contained in:
David Rousselie
2008-05-28 18:22:41 +02:00
parent a43d0b9a3a
commit c54690435d
7 changed files with 201 additions and 91 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/jcl/jabber/command.py
View File

@@ -704,7 +704,7 @@ class JCLCommandManager(CommandManager):
name, user_jid = self.get_name_and_jid(account_name) name, user_jid = self.get_name_and_jid(account_name)
_account = account.get_account(user_jid, name) _account = account.get_account(user_jid, name)
result += self.component.account_manager.get_account_presence_unavailable( result += self.component.account_manager.get_account_presence_unavailable(
_account) _account.user.jid, _account)
command_node.setProp("status", STATUS_COMPLETED) command_node.setProp("status", STATUS_COMPLETED)
return (None, result) return (None, result)

42
src/jcl/jabber/component.py
View File

@@ -345,7 +345,7 @@ class AccountManager(object):
presence)) presence))
for _account in account.get_all_accounts(): for _account in account.get_all_accounts():
result.extend(getattr(self, "get_account_presence_" + result.extend(getattr(self, "get_account_presence_" +
presence)(_account)) presence)(_account.user.jid, _account))
return result return result
def get_root_presence(self, to_jid, presence_type, def get_root_presence(self, to_jid, presence_type,
@@ -370,32 +370,28 @@ class AccountManager(object):
show=show, show=show,
stanza_type=presence_type) stanza_type=presence_type)
def get_account_presence_probe(self, _account): def get_account_presence_unavailable(self, to_jid, _account):
"""Send presence probe to account's user"""
return [self.get_presence(from_jid=_account.jid,
to_jid=_account.user.jid,
presence_type="probe")]
def get_account_presence_unavailable(self, _account):
"""Send unavailable presence to account's user""" """Send unavailable presence to account's user"""
_account.status = account.OFFLINE _account.status = account.OFFLINE
return [self.get_presence(from_jid=_account.jid, return [self.get_presence(from_jid=_account.jid,
to_jid=_account.user.jid, to_jid=to_jid,
presence_type="unavailable")] presence_type="unavailable")]
def get_account_presence_available(self, _account, lang_class): def get_account_presence_available(self, to_jid, _account, lang_class,
update=False):
"""Send available presence to account's user and ask for password """Send available presence to account's user and ask for password
if necessary""" if necessary"""
result = [] result = []
old_status = _account.status old_status = _account.status
_account.status = account.ONLINE
if _account.error is not None: if _account.error is not None:
_account.status = account.DND _account.status = account.DND
elif not _account.enabled: elif not _account.enabled:
_account.status = account.XA _account.status = account.XA
if old_status != _account.status: else:
_account.status = account.ONLINE
if not update or old_status != _account.status:
result.append(self.get_presence(from_jid=_account.jid, result.append(self.get_presence(from_jid=_account.jid,
to_jid=_account.user.jid, to_jid=to_jid,
status=_account.status_msg, status=_account.status_msg,
show=_account.status, show=_account.status,
presence_type="available")) presence_type="available"))
@@ -404,7 +400,7 @@ class AccountManager(object):
and _account.store_password == False \ and _account.store_password == False \
and old_status == account.OFFLINE \ and old_status == account.OFFLINE \
and _account.password == None : and _account.password == None :
result.extend(self.ask_password(_account, lang_class)) result.extend(self.ask_password(to_jid, _account, lang_class))
return result return result
def probe_all_accounts_presence(self): def probe_all_accounts_presence(self):
@@ -413,11 +409,9 @@ class AccountManager(object):
user.jid, user.jid,
"available") "available")
for user in account.get_all_users()] for user in account.get_all_users()]
result += [self.get_presence(from_jid=_account.jid, result += [self.get_account_presence_available(\
to_jid=_account.user.jid, _account.user.jid, _account,
status=_account.status_msg, _account.default_lang_class)[0]
show=_account.status,
presence_type="available")
for _account in account.get_all_accounts()] for _account in account.get_all_accounts()]
return result return result
@@ -531,7 +525,7 @@ class AccountManager(object):
"""Compose account jid from account name""" """Compose account jid from account name"""
return name + u"@" + unicode(self.component.jid) return name + u"@" + unicode(self.component.jid)
def ask_password(self, _account, lang_class): def ask_password(self, to_jid, _account, lang_class):
"""Send a Jabber message to ask for account password """Send a Jabber message to ask for account password
""" """
result = [] result = []
@@ -540,7 +534,7 @@ class AccountManager(object):
and _account.status != account.OFFLINE: and _account.status != account.OFFLINE:
_account.waiting_password_reply = True _account.waiting_password_reply = True
result.append(Message(from_jid=_account.jid, result.append(Message(from_jid=_account.jid,
to_jid=_account.user.jid, to_jid=to_jid,
subject=u"[PASSWORD] " + \ subject=u"[PASSWORD] " + \
lang_class.ask_password_subject, lang_class.ask_password_subject,
body=lang_class.ask_password_body % \ body=lang_class.ask_password_body % \
@@ -575,14 +569,16 @@ class AccountManager(object):
body=_account.default_lang_class.error_body \ body=_account.default_lang_class.error_body \
% (exception))) % (exception)))
result.extend(self.get_account_presence_available(\ result.extend(self.get_account_presence_available(\
_account, _account.default_lang_class)) _account.user.jid, _account, _account.default_lang_class,
True))
return result return result
def cancel_account_error(self, _account): def cancel_account_error(self, _account):
"""Reset Account error status and send new available presence""" """Reset Account error status and send new available presence"""
_account.error = None _account.error = None
self.component.send_stanzas(self.get_account_presence_available(\ self.component.send_stanzas(self.get_account_presence_available(\
_account, _account.default_lang_class)) _account.user.jid, _account, _account.default_lang_class,
True))
############################################################################### ###############################################################################
# JCL implementation # JCL implementation

5
src/jcl/jabber/presence.py
View File

@@ -84,7 +84,7 @@ class AccountPresenceAvailableHandler(AccountPresenceHandler):
def get_account_presence(self, stanza, lang_class, _account): def get_account_presence(self, stanza, lang_class, _account):
_account.default_lang_class = lang_class _account.default_lang_class = lang_class
return self.component.account_manager.get_account_presence_available(\ return self.component.account_manager.get_account_presence_available(\
_account, lang_class) stanza.get_from(), _account, lang_class)
class RootPresenceHandler(AccountPresenceHandler): class RootPresenceHandler(AccountPresenceHandler):
filter = jabber.get_accounts_root_filter filter = jabber.get_accounts_root_filter
@@ -123,11 +123,10 @@ class RootPresenceAvailableHandler(RootPresenceHandler, AccountPresenceAvailable
body=motd)) body=motd))
return result return result
class AccountPresenceUnavailableHandler(AccountPresenceHandler): class AccountPresenceUnavailableHandler(AccountPresenceHandler):
def get_account_presence(self, stanza, lang_class, _account): def get_account_presence(self, stanza, lang_class, _account):
return self.component.account_manager.get_account_presence_unavailable(\ return self.component.account_manager.get_account_presence_unavailable(\
_account) stanza.get_from(), _account)
class RootPresenceUnavailableHandler(RootPresenceHandler, AccountPresenceUnavailableHandler): class RootPresenceUnavailableHandler(RootPresenceHandler, AccountPresenceUnavailableHandler):
def get_root_presence(self, stanza, lang_class, nb_accounts): def get_root_presence(self, stanza, lang_class, nb_accounts):

4
src/jcl/jabber/tests/command.py
View File

@@ -3208,7 +3208,7 @@ class JCLCommandManagerShutdownCommand_TestCase(JCLCommandManagerTestCase):
from_jid="admin@test.com", from_jid="admin@test.com",
fields=[Field(field_type="list-multi", fields=[Field(field_type="list-multi",
name="delay", name="delay",
value=[0])]) value=[1])])
result = self.command_manager.apply_command_action(\ result = self.command_manager.apply_command_action(\
info_query, info_query,
"http://jabber.org/protocol/admin#shutdown", "http://jabber.org/protocol/admin#shutdown",
@@ -3234,7 +3234,7 @@ class JCLCommandManagerShutdownCommand_TestCase(JCLCommandManagerTestCase):
context_session = self.command_manager.sessions[session_id][1] context_session = self.command_manager.sessions[session_id][1]
self.assertFalse(context_session.has_key("announcement")) self.assertFalse(context_session.has_key("announcement"))
self.assertEquals(context_session["delay"], self.assertEquals(context_session["delay"],
["0"]) ["1"])
class JCLCommandManagerGetLastErrorCommand_TestCase(JCLCommandManagerTestCase): class JCLCommandManagerGetLastErrorCommand_TestCase(JCLCommandManagerTestCase):
""" """

115
src/jcl/jabber/tests/component.py
View File

@@ -1290,27 +1290,27 @@ class JCLComponent_TestCase(JCLTestCase):
self.comp.stream_class = MockStream self.comp.stream_class = MockStream
self.comp.account_manager.account_classes = (ExampleAccount,) self.comp.account_manager.account_classes = (ExampleAccount,)
x_data = Form("submit") x_data = Form("submit")
x_data.add_field(name = "name", \ x_data.add_field(name="name",
value = "account1", \ value="account1",
field_type = "text-single") field_type="text-single")
x_data.add_field(name = "login", \ x_data.add_field(name="login",
value = "mylogin", \ value="mylogin",
field_type = "text-single") field_type="text-single")
x_data.add_field(name = "password", \ x_data.add_field(name="password",
value = "mypassword", \ value="mypassword",
field_type = "text-private") field_type="text-private")
x_data.add_field(name = "store_password", \ x_data.add_field(name="store_password",
value = False, \ value=False,
field_type = "boolean") field_type="boolean")
x_data.add_field(name = "test_enum", \ x_data.add_field(name="test_enum",
value = "choice3", \ value="choice3",
field_type = "list-single") field_type="list-single")
x_data.add_field(name = "test_int", \ x_data.add_field(name="test_int",
value = 43, \ value=43,
field_type = "text-single") field_type="text-single")
iq_set = Iq(stanza_type = "set", \ iq_set = Iq(stanza_type="set",
from_jid = "user1@test.com", \ from_jid="user1@test.com/resource",
to_jid = "jcl.test.com") to_jid="jcl.test.com")
query = iq_set.new_query("jabber:iq:register") query = iq_set.new_query("jabber:iq:register")
x_data.as_xml(query, None) x_data.as_xml(query, None)
self.comp.handle_set_register(iq_set) self.comp.handle_set_register(iq_set)
@@ -1334,29 +1334,29 @@ class JCLComponent_TestCase(JCLTestCase):
self.assertTrue(isinstance(iq_result, Iq)) self.assertTrue(isinstance(iq_result, Iq))
self.assertEquals(iq_result.get_node().prop("type"), "result") self.assertEquals(iq_result.get_node().prop("type"), "result")
self.assertEquals(iq_result.get_from(), "jcl.test.com") self.assertEquals(iq_result.get_from(), "jcl.test.com")
self.assertEquals(iq_result.get_to(), "user1@test.com") self.assertEquals(iq_result.get_to(), "user1@test.com/resource")
presence_component = stanza_sent[1] presence_component = stanza_sent[1]
self.assertTrue(isinstance(presence_component, Presence)) self.assertTrue(isinstance(presence_component, Presence))
self.assertEquals(presence_component.get_from(), "jcl.test.com") self.assertEquals(presence_component.get_from(), "jcl.test.com")
self.assertEquals(presence_component.get_to(), "user1@test.com") self.assertEquals(presence_component.get_to(), "user1@test.com")
self.assertEquals(presence_component.get_node().prop("type"), \ self.assertEquals(presence_component.get_node().prop("type"),
"subscribe") "subscribe")
message = stanza_sent[2] message = stanza_sent[2]
self.assertTrue(isinstance(message, Message)) self.assertTrue(isinstance(message, Message))
self.assertEquals(message.get_from(), "jcl.test.com") self.assertEquals(message.get_from(), "jcl.test.com")
self.assertEquals(message.get_to(), "user1@test.com") self.assertEquals(message.get_to(), "user1@test.com/resource")
self.assertEquals(message.get_subject(), \ self.assertEquals(message.get_subject(),
_account.get_new_message_subject(Lang.en)) _account.get_new_message_subject(Lang.en))
self.assertEquals(message.get_body(), \ self.assertEquals(message.get_body(),
_account.get_new_message_body(Lang.en)) _account.get_new_message_body(Lang.en))
presence_account = stanza_sent[3] presence_account = stanza_sent[3]
self.assertTrue(isinstance(presence_account, Presence)) self.assertTrue(isinstance(presence_account, Presence))
self.assertEquals(presence_account.get_from(), "account1@jcl.test.com") self.assertEquals(presence_account.get_from(), "account1@jcl.test.com")
self.assertEquals(presence_account.get_to(), "user1@test.com") self.assertEquals(presence_account.get_to(), "user1@test.com")
self.assertEquals(presence_account.get_node().prop("type"), \ self.assertEquals(presence_account.get_node().prop("type"),
"subscribe") "subscribe")
def test_handle_set_register_new_default_values(self): def test_handle_set_register_new_default_values(self):
@@ -1471,6 +1471,7 @@ class JCLComponent_TestCase(JCLTestCase):
self.assertEquals(len(stanza_sent), 1) self.assertEquals(len(stanza_sent), 1)
self.assertTrue(isinstance(stanza_sent[0], Iq)) self.assertTrue(isinstance(stanza_sent[0], Iq))
self.assertEquals(stanza_sent[0].get_node().prop("type"), "error") self.assertEquals(stanza_sent[0].get_node().prop("type"), "error")
self.assertEquals(stanza_sent[0].get_to(), "user1@test.com/res")
stanza_error = stanza_sent[0].get_error() stanza_error = stanza_sent[0].get_error()
self.assertEquals(stanza_error.get_condition().name, self.assertEquals(stanza_error.get_condition().name,
"not-acceptable") "not-acceptable")
@@ -1501,6 +1502,7 @@ class JCLComponent_TestCase(JCLTestCase):
self.assertEquals(len(stanza_sent), 1) self.assertEquals(len(stanza_sent), 1)
self.assertTrue(isinstance(stanza_sent[0], Iq)) self.assertTrue(isinstance(stanza_sent[0], Iq))
self.assertEquals(stanza_sent[0].get_node().prop("type"), "error") self.assertEquals(stanza_sent[0].get_node().prop("type"), "error")
self.assertEquals(stanza_sent[0].get_to(), "user1@test.com/res")
stanza_error = stanza_sent[0].get_error() stanza_error = stanza_sent[0].get_error()
self.assertEquals(stanza_error.get_condition().name, self.assertEquals(stanza_error.get_condition().name,
"not-acceptable") "not-acceptable")
@@ -1727,13 +1729,13 @@ class JCLComponent_TestCase(JCLTestCase):
model.db_disconnect() model.db_disconnect()
self.comp.handle_presence_available(Presence(\ self.comp.handle_presence_available(Presence(\
stanza_type="available", stanza_type="available",
from_jid="user1@test.com", from_jid="user1@test.com/resource",
to_jid="jcl.test.com")) to_jid="jcl.test.com"))
presence_sent = self.comp.stream.sent presence_sent = self.comp.stream.sent
self.assertEqual(len(presence_sent), 3) self.assertEqual(len(presence_sent), 3)
self.assertEqual(len([presence self.assertEqual(len([presence
for presence in presence_sent for presence in presence_sent
if presence.get_to_jid() == "user1@test.com" \ if presence.get_to_jid() == "user1@test.com/resource" \
and presence.get_type() is None]), and presence.get_type() is None]),
3) 3)
self.assertEqual(len([presence self.assertEqual(len([presence
@@ -1790,13 +1792,13 @@ class JCLComponent_TestCase(JCLTestCase):
model.db_disconnect() model.db_disconnect()
self.comp.handle_presence_available(Presence(\ self.comp.handle_presence_available(Presence(\
stanza_type="available", stanza_type="available",
from_jid="user1@test.com", from_jid="user1@test.com/resource",
to_jid="jcl.test.com")) to_jid="jcl.test.com"))
presence_sent = self.comp.stream.sent presence_sent = self.comp.stream.sent
self.assertEqual(len(presence_sent), 7) self.assertEqual(len(presence_sent), 7)
self.assertEqual(len([presence self.assertEqual(len([presence
for presence in presence_sent for presence in presence_sent
if presence.get_to_jid() == "user1@test.com" \ if presence.get_to_jid() == "user1@test.com/resource" \
and presence.get_type() is None]), and presence.get_type() is None]),
7) 7)
self.assertEqual(len([presence self.assertEqual(len([presence
@@ -1888,11 +1890,11 @@ class JCLComponent_TestCase(JCLTestCase):
model.db_disconnect() model.db_disconnect()
self.comp.handle_presence_available(Presence(\ self.comp.handle_presence_available(Presence(\
stanza_type="available", stanza_type="available",
from_jid="user1@test.com", from_jid="user1@test.com/resource",
to_jid="account11@jcl.test.com")) to_jid="account11@jcl.test.com"))
presence_sent = self.comp.stream.sent presence_sent = self.comp.stream.sent
self.assertEqual(len(presence_sent), 1) self.assertEqual(len(presence_sent), 1)
self.assertEqual(presence_sent[0].get_to(), "user1@test.com") self.assertEqual(presence_sent[0].get_to(), "user1@test.com/resource")
self.assertEqual(presence_sent[0].get_from(), "account11@jcl.test.com") self.assertEqual(presence_sent[0].get_from(), "account11@jcl.test.com")
self.assertTrue(isinstance(presence_sent[0], Presence)) self.assertTrue(isinstance(presence_sent[0], Presence))
self.assertEqual(presence_sent[0].get_type(), None) self.assertEqual(presence_sent[0].get_type(), None)
@@ -1915,11 +1917,11 @@ class JCLComponent_TestCase(JCLTestCase):
model.db_disconnect() model.db_disconnect()
self.comp.handle_presence_available(Presence(\ self.comp.handle_presence_available(Presence(\
stanza_type="available", stanza_type="available",
from_jid="user1@test.com", from_jid="user1@test.com/resource",
to_jid="user1%test.com@jcl.test.com")) to_jid="user1%test.com@jcl.test.com"))
presence_sent = self.comp.stream.sent presence_sent = self.comp.stream.sent
self.assertEqual(len(presence_sent), 1) self.assertEqual(len(presence_sent), 1)
self.assertEqual(presence_sent[0].get_to(), "user1@test.com") self.assertEqual(presence_sent[0].get_to(), "user1@test.com/resource")
self.assertEqual(presence_sent[0].get_from(), self.assertEqual(presence_sent[0].get_from(),
"user1%test.com@jcl.test.com") "user1%test.com@jcl.test.com")
self.assertTrue(isinstance(presence_sent[0], Presence)) self.assertTrue(isinstance(presence_sent[0], Presence))
@@ -1987,7 +1989,7 @@ class JCLComponent_TestCase(JCLTestCase):
model.db_disconnect() model.db_disconnect()
self.comp.handle_presence_available(Presence(\ self.comp.handle_presence_available(Presence(\
stanza_type="available", stanza_type="available",
from_jid="user1@test.com", from_jid="user1@test.com/resource",
to_jid="account11@jcl.test.com")) to_jid="account11@jcl.test.com"))
messages_sent = self.comp.stream.sent messages_sent = self.comp.stream.sent
self.assertEqual(len(messages_sent), 1) self.assertEqual(len(messages_sent), 1)
@@ -1995,7 +1997,7 @@ class JCLComponent_TestCase(JCLTestCase):
self.assertTrue(presence is not None) self.assertTrue(presence is not None)
self.assertTrue(isinstance(presence, Presence)) self.assertTrue(isinstance(presence, Presence))
self.assertEqual(presence.get_from_jid(), "account11@jcl.test.com") self.assertEqual(presence.get_from_jid(), "account11@jcl.test.com")
self.assertEqual(presence.get_to_jid(), "user1@test.com") self.assertEqual(presence.get_to_jid(), "user1@test.com/resource")
self.assertEqual(presence.get_type(), None) self.assertEqual(presence.get_type(), None)
def test_handle_presence_available_to_account_live_password_complex(self): def test_handle_presence_available_to_account_live_password_complex(self):
@@ -2016,7 +2018,7 @@ class JCLComponent_TestCase(JCLTestCase):
model.db_disconnect() model.db_disconnect()
self.comp.handle_presence_available(Presence(\ self.comp.handle_presence_available(Presence(\
stanza_type="available", stanza_type="available",
from_jid="user1@test.com", from_jid="user1@test.com/resource",
to_jid="account11@jcl.test.com")) to_jid="account11@jcl.test.com"))
messages_sent = self.comp.stream.sent messages_sent = self.comp.stream.sent
self.assertEqual(len(messages_sent), 2) self.assertEqual(len(messages_sent), 2)
@@ -2031,13 +2033,13 @@ class JCLComponent_TestCase(JCLTestCase):
self.assertTrue(presence is not None) self.assertTrue(presence is not None)
self.assertTrue(isinstance(presence, Presence)) self.assertTrue(isinstance(presence, Presence))
self.assertEqual(presence.get_from_jid(), "account11@jcl.test.com") self.assertEqual(presence.get_from_jid(), "account11@jcl.test.com")
self.assertEqual(presence.get_to_jid(), "user1@test.com") self.assertEqual(presence.get_to_jid(), "user1@test.com/resource")
self.assertEqual(presence.get_type(), None) self.assertEqual(presence.get_type(), None)
self.assertEqual(unicode(password_message.get_from_jid()), \ self.assertEqual(unicode(password_message.get_from_jid()), \
"account11@jcl.test.com") "account11@jcl.test.com")
self.assertEqual(unicode(password_message.get_to_jid()), \ self.assertEqual(unicode(password_message.get_to_jid()), \
"user1@test.com") "user1@test.com/resource")
self.assertEqual(password_message.get_subject(), \ self.assertEqual(password_message.get_subject(), \
"[PASSWORD] Password request") "[PASSWORD] Password request")
self.assertEqual(password_message.get_body(), \ self.assertEqual(password_message.get_body(), \
@@ -2060,13 +2062,13 @@ class JCLComponent_TestCase(JCLTestCase):
model.db_disconnect() model.db_disconnect()
self.comp.handle_presence_unavailable(Presence(\ self.comp.handle_presence_unavailable(Presence(\
stanza_type="unavailable", stanza_type="unavailable",
from_jid="user1@test.com", from_jid="user1@test.com/resource",
to_jid="jcl.test.com")) to_jid="jcl.test.com"))
presence_sent = self.comp.stream.sent presence_sent = self.comp.stream.sent
self.assertEqual(len(presence_sent), 3) self.assertEqual(len(presence_sent), 3)
self.assertEqual(len([presence self.assertEqual(len([presence
for presence in presence_sent for presence in presence_sent
if presence.get_to_jid() == "user1@test.com" \ if presence.get_to_jid() == "user1@test.com/resource" \
and presence.get_type() == "unavailable"]), and presence.get_type() == "unavailable"]),
3) 3)
self.assertEqual(\ self.assertEqual(\
@@ -2126,13 +2128,13 @@ class JCLComponent_TestCase(JCLTestCase):
model.db_disconnect() model.db_disconnect()
self.comp.handle_presence_unavailable(Presence(\ self.comp.handle_presence_unavailable(Presence(\
stanza_type="unavailable", stanza_type="unavailable",
from_jid="user1@test.com", from_jid="user1@test.com/resource",
to_jid="jcl.test.com")) to_jid="jcl.test.com"))
presence_sent = self.comp.stream.sent presence_sent = self.comp.stream.sent
self.assertEqual(len(presence_sent), 7) self.assertEqual(len(presence_sent), 7)
self.assertEqual(len([presence self.assertEqual(len([presence
for presence in presence_sent for presence in presence_sent
if presence.get_to_jid() == "user1@test.com" \ if presence.get_to_jid() == "user1@test.com/resource" \
and presence.get_type() == "unavailable"]), and presence.get_type() == "unavailable"]),
7) 7)
self.assertEqual(len([presence self.assertEqual(len([presence
@@ -2224,11 +2226,11 @@ class JCLComponent_TestCase(JCLTestCase):
model.db_disconnect() model.db_disconnect()
self.comp.handle_presence_unavailable(Presence(\ self.comp.handle_presence_unavailable(Presence(\
stanza_type="unavailable", stanza_type="unavailable",
from_jid="user1@test.com", from_jid="user1@test.com/resource",
to_jid="account11@jcl.test.com")) to_jid="account11@jcl.test.com"))
presence_sent = self.comp.stream.sent presence_sent = self.comp.stream.sent
self.assertEqual(len(presence_sent), 1) self.assertEqual(len(presence_sent), 1)
self.assertEqual(presence_sent[0].get_to(), "user1@test.com") self.assertEqual(presence_sent[0].get_to(), "user1@test.com/resource")
self.assertEqual(presence_sent[0].get_from(), "account11@jcl.test.com") self.assertEqual(presence_sent[0].get_from(), "account11@jcl.test.com")
self.assertEqual(\ self.assertEqual(\
presence_sent[0].xpath_eval("@type")[0].get_content(), presence_sent[0].xpath_eval("@type")[0].get_content(),
@@ -2252,12 +2254,13 @@ class JCLComponent_TestCase(JCLTestCase):
model.db_disconnect() model.db_disconnect()
self.comp.handle_presence_unavailable(Presence(\ self.comp.handle_presence_unavailable(Presence(\
stanza_type="unavailable", stanza_type="unavailable",
from_jid="user1@test.com", from_jid="user1@test.com/resource",
to_jid="user1%test.com@jcl.test.com")) to_jid="user1%test.com@jcl.test.com"))
presence_sent = self.comp.stream.sent presence_sent = self.comp.stream.sent
self.assertEqual(len(presence_sent), 1) self.assertEqual(len(presence_sent), 1)
self.assertEqual(presence_sent[0].get_to(), "user1@test.com") self.assertEqual(presence_sent[0].get_to(), "user1@test.com/resource")
self.assertEqual(presence_sent[0].get_from(), "user1%test.com@jcl.test.com") self.assertEqual(presence_sent[0].get_from(),
"user1%test.com@jcl.test.com")
self.assertEqual(\ self.assertEqual(\
presence_sent[0].xpath_eval("@type")[0].get_content(), presence_sent[0].xpath_eval("@type")[0].get_content(),
"unavailable") "unavailable")
@@ -3202,6 +3205,18 @@ class AccountManager_TestCase(JCLTestCase):
self.assertEquals(presence.children.name, "show") self.assertEquals(presence.children.name, "show")
self.assertEquals(presence.children.content, "online") self.assertEquals(presence.children.content, "online")
def test_cancel_account_error_no_error(self):
"""Test Account error reset"""
self.comp.stream = MockStream()
self.comp.stream_class = MockStream
_account = Account(user=User(jid="user1@test.com"),
name="account11",
jid="account11@jcl.test.com")
_account.error = None
_account.status = account.ONLINE
self.account_manager.cancel_account_error(_account)
self.assertEquals(len(self.comp.stream.sent), 0)
def test_get_account_presence_available_no_change(self): def test_get_account_presence_available_no_change(self):
"""Test when presence status does not change""" """Test when presence status does not change"""
_account = Account(user=User(jid="user1@test.com"), _account = Account(user=User(jid="user1@test.com"),
@@ -3209,7 +3224,7 @@ class AccountManager_TestCase(JCLTestCase):
jid="account11@jcl.test.com") jid="account11@jcl.test.com")
_account.status = account.ONLINE _account.status = account.ONLINE
result = self.account_manager.get_account_presence_available(\ result = self.account_manager.get_account_presence_available(\
_account, _account.default_lang_class) _account.user.jid, _account, _account.default_lang_class, True)
self.assertEquals(len(result), 0) self.assertEquals(len(result), 0)
def suite(): def suite():

14
src/jcl/jabber/tests/message.py
View File

@@ -55,7 +55,7 @@ class PasswordMessageHandler_TestCase(JCLTestCase):
account12 = ExampleAccount(user=user1, account12 = ExampleAccount(user=user1,
name="account12", name="account12",
jid="account12@jcl.test.com") jid="account12@jcl.test.com")
message = Message(from_jid="user1@test.com", message = Message(from_jid="user1@test.com/resource",
to_jid="account11@jcl.test.com", to_jid="account11@jcl.test.com",
subject="[PASSWORD]", subject="[PASSWORD]",
body="secret") body="secret")
@@ -73,7 +73,7 @@ class PasswordMessageHandler_TestCase(JCLTestCase):
account12 = ExampleAccount(user=user1, account12 = ExampleAccount(user=user1,
name="account12", name="account12",
jid="account12@jcl.test.com") jid="account12@jcl.test.com")
message = Message(from_jid="user1@test.com", message = Message(from_jid="user1@test.com/resource",
to_jid="account11@jcl.test.com", to_jid="account11@jcl.test.com",
subject="[PASSWORD]", subject="[PASSWORD]",
body="secret") body="secret")
@@ -125,7 +125,7 @@ class PasswordMessageHandler_TestCase(JCLTestCase):
account12 = ExampleAccount(user=user1, account12 = ExampleAccount(user=user1,
name="account12", name="account12",
jid="account12@jcl.test.com") jid="account12@jcl.test.com")
message = Message(from_jid="user1@test.com", message = Message(from_jid="user1@test.com/resource",
to_jid="account11@jcl.test.com", to_jid="account11@jcl.test.com",
subject="[PASSWORD]", subject="[PASSWORD]",
body="secret") body="secret")
@@ -152,7 +152,7 @@ class HelpMessageHandler_TestCase(JCLTestCase):
account12 = ExampleAccount(user=user1, account12 = ExampleAccount(user=user1,
name="account12", name="account12",
jid="account12@jcl.test.com") jid="account12@jcl.test.com")
message = Message(from_jid="user1@test.com", message = Message(from_jid="user1@test.com/resource",
to_jid="account11@jcl.test.com", to_jid="account11@jcl.test.com",
subject="", subject="",
body="help") body="help")
@@ -167,7 +167,7 @@ class HelpMessageHandler_TestCase(JCLTestCase):
account12 = ExampleAccount(user=user1, account12 = ExampleAccount(user=user1,
name="account12", name="account12",
jid="account12@jcl.test.com") jid="account12@jcl.test.com")
message = Message(from_jid="user1@test.com", message = Message(from_jid="user1@test.com/resource",
to_jid="account11@jcl.test.com", to_jid="account11@jcl.test.com",
subject="", subject="",
body="help dalkjdjhbd") body="help dalkjdjhbd")
@@ -212,14 +212,14 @@ class HelpMessageHandler_TestCase(JCLTestCase):
account12 = ExampleAccount(user=user1, account12 = ExampleAccount(user=user1,
name="account12", name="account12",
jid="account12@jcl.test.com") jid="account12@jcl.test.com")
message = Message(from_jid="user1@test.com", message = Message(from_jid="user1@test.com/resource",
to_jid="account11@jcl.test.com", to_jid="account11@jcl.test.com",
subject="", subject="",
body="help") body="help")
messages = self.handler.handle(message, Lang.en, account11) messages = self.handler.handle(message, Lang.en, account11)
self.assertEquals(len(messages), 1) self.assertEquals(len(messages), 1)
self.assertEquals(messages[0].get_from(), "account11@jcl.test.com") self.assertEquals(messages[0].get_from(), "account11@jcl.test.com")
self.assertEquals(messages[0].get_to(), "user1@test.com") self.assertEquals(messages[0].get_to(), "user1@test.com/resource")
self.assertEquals(messages[0].get_subject(), Lang.en.help_message_subject) self.assertEquals(messages[0].get_subject(), Lang.en.help_message_subject)
self.assertEquals(messages[0].get_body(), Lang.en.help_message_body) self.assertEquals(messages[0].get_body(), Lang.en.help_message_body)

110
src/jcl/jabber/tests/presence.py
View File

@@ -3,18 +3,18 @@
## Login : David Rousselie <dax@happycoders.org> ## Login : David Rousselie <dax@happycoders.org>
## Started on Fri Jul 6 21:45:43 2007 David Rousselie ## Started on Fri Jul 6 21:45:43 2007 David Rousselie
## $Id$ ## $Id$
## ##
## Copyright (C) 2007 David Rousselie ## Copyright (C) 2007 David Rousselie
## This program is free software; you can redistribute it and/or modify ## This program is free software; you can redistribute it and/or modify
## it under the terms of the GNU General Public License as published by ## it under the terms of the GNU General Public License as published by
## the Free Software Foundation; either version 2 of the License, or ## the Free Software Foundation; either version 2 of the License, or
## (at your option) any later version. ## (at your option) any later version.
## ##
## This program is distributed in the hope that it will be useful, ## This program is distributed in the hope that it will be useful,
## but WITHOUT ANY WARRANTY; without even the implied warranty of ## but WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
## GNU General Public License for more details. ## GNU General Public License for more details.
## ##
## You should have received a copy of the GNU General Public License ## You should have received a copy of the GNU General Public License
## along with this program; if not, write to the Free Software ## along with this program; if not, write to the Free Software
## Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA ## Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
@@ -31,12 +31,13 @@ from pyxmpp.message import Message
from jcl.jabber.component import JCLComponent from jcl.jabber.component import JCLComponent
from jcl.jabber.presence import DefaultSubscribeHandler, \ from jcl.jabber.presence import DefaultSubscribeHandler, \
DefaultUnsubscribeHandler, DefaultPresenceHandler, \ DefaultUnsubscribeHandler, DefaultPresenceHandler, \
RootPresenceAvailableHandler, AccountPresenceAvailableHandler RootPresenceAvailableHandler, AccountPresenceAvailableHandler, \
AccountPresenceUnavailableHandler
from jcl.model.account import User, LegacyJID, Account from jcl.model.account import User, LegacyJID, Account
from jcl.lang import Lang from jcl.lang import Lang
from jcl.tests import JCLTestCase from jcl.tests import JCLTestCase
class DefaultSubscribeHandler_TestCase(unittest.TestCase): class DefaultSubscribeHandler_TestCase(unittest.TestCase):
def setUp(self): def setUp(self):
self.handler = DefaultSubscribeHandler(None) self.handler = DefaultSubscribeHandler(None)
@@ -140,6 +141,29 @@ class RootPresenceAvailableHandler_TestCase(JCLTestCase):
self.assertEquals(result[1].get_from(), "jcl.test.com") self.assertEquals(result[1].get_from(), "jcl.test.com")
self.assertEquals(result[1].get_body(), "Message Of The Day") self.assertEquals(result[1].get_body(), "Message Of The Day")
def test_get_root_presence_with_resource(self):
user1 = User(jid="user1@test.com")
account11 = Account(user=user1,
name="account11",
jid="account11@jcl.test.com")
account12 = Account(user=user1,
name="account12",
jid="account12@jcl.test.com")
presence = Presence(stanza_type="available",
from_jid="user1@test.com/resource",
to_jid="jcl.test.com")
self.assertFalse(user1.has_received_motd)
result = self.handler.get_root_presence(presence, Lang.en, 2)
self.assertTrue(user1.has_received_motd)
self.assertEquals(len(result), 2)
self.assertTrue(isinstance(result[0], Presence))
self.assertEquals(result[0].get_to(), "user1@test.com/resource")
self.assertEquals(result[0].get_from(), "jcl.test.com")
self.assertTrue(isinstance(result[1], Message))
self.assertEquals(result[1].get_to(), "user1@test.com/resource")
self.assertEquals(result[1].get_from(), "jcl.test.com")
self.assertEquals(result[1].get_body(), "Message Of The Day")
def test_get_root_presence_already_received_motd(self): def test_get_root_presence_already_received_motd(self):
user1 = User(jid="user1@test.com") user1 = User(jid="user1@test.com")
user1.has_received_motd = True user1.has_received_motd = True
@@ -221,6 +245,25 @@ class AccountPresenceAvailableHandler_TestCase(JCLTestCase):
self.assertEquals(result[0].get_show(), "online") self.assertEquals(result[0].get_show(), "online")
self.assertEquals(result[0].get_status(), "account11") self.assertEquals(result[0].get_status(), "account11")
def test_get_account_presence_with_resource(self):
user1 = User(jid="user1@test.com")
account11 = Account(user=user1,
name="account11",
jid="account11@jcl.test.com")
account12 = Account(user=user1,
name="account12",
jid="account12@jcl.test.com")
presence = Presence(stanza_type="available",
from_jid="user1@test.com/resource",
to_jid="account11@jcl.test.com")
result = self.handler.get_account_presence(presence, Lang.en, account11)
self.assertEquals(len(result), 1)
self.assertTrue(isinstance(result[0], Presence))
self.assertEquals(result[0].get_to(), "user1@test.com/resource")
self.assertEquals(result[0].get_from(), "account11@jcl.test.com")
self.assertEquals(result[0].get_show(), "online")
self.assertEquals(result[0].get_status(), "account11")
def test_get_disabled_account_presence(self): def test_get_disabled_account_presence(self):
user1 = User(jid="user1@test.com") user1 = User(jid="user1@test.com")
account11 = Account(user=user1, account11 = Account(user=user1,
@@ -261,6 +304,62 @@ class AccountPresenceAvailableHandler_TestCase(JCLTestCase):
self.assertEquals(result[0].get_show(), "dnd") self.assertEquals(result[0].get_show(), "dnd")
self.assertEquals(result[0].get_status(), Lang.en.account_error) self.assertEquals(result[0].get_status(), Lang.en.account_error)
class AccountPresenceUnavailableHandler_TestCase(JCLTestCase):
def setUp(self):
JCLTestCase.setUp(self, tables=[User, LegacyJID, Account])
self.config = ConfigParser()
self.config_file = tempfile.mktemp(".conf", "jcltest", "/tmp")
self.config.read(self.config_file)
self.config.add_section("component")
self.config.set("component", "motd", "Message Of The Day")
self.comp = JCLComponent("jcl.test.com",
"password",
"localhost",
"5347",
self.config)
self.handler = AccountPresenceUnavailableHandler(self.comp)
def tearDown(self):
JCLTestCase.tearDown(self)
if os.path.exists(self.config_file):
os.unlink(self.config_file)
def test_get_account_presence(self):
user1 = User(jid="user1@test.com")
account11 = Account(user=user1,
name="account11",
jid="account11@jcl.test.com")
account12 = Account(user=user1,
name="account12",
jid="account12@jcl.test.com")
presence = Presence(stanza_type="unavailable",
from_jid="user1@test.com",
to_jid="account11@jcl.test.com")
result = self.handler.get_account_presence(presence, Lang.en, account11)
self.assertEquals(len(result), 1)
self.assertTrue(isinstance(result[0], Presence))
self.assertEquals(result[0].get_to(), "user1@test.com")
self.assertEquals(result[0].get_from(), "account11@jcl.test.com")
self.assertEquals(result[0].get_type(), "unavailable")
def test_get_account_presence_with_resource(self):
user1 = User(jid="user1@test.com")
account11 = Account(user=user1,
name="account11",
jid="account11@jcl.test.com")
account12 = Account(user=user1,
name="account12",
jid="account12@jcl.test.com")
presence = Presence(stanza_type="unavailable",
from_jid="user1@test.com/resource",
to_jid="account11@jcl.test.com")
result = self.handler.get_account_presence(presence, Lang.en, account11)
self.assertEquals(len(result), 1)
self.assertTrue(isinstance(result[0], Presence))
self.assertEquals(result[0].get_to(), "user1@test.com/resource")
self.assertEquals(result[0].get_from(), "account11@jcl.test.com")
self.assertEquals(result[0].get_type(), "unavailable")
def suite(): def suite():
test_suite = unittest.TestSuite() test_suite = unittest.TestSuite()
test_suite.addTest(unittest.makeSuite(DefaultSubscribeHandler_TestCase, 'test')) test_suite.addTest(unittest.makeSuite(DefaultSubscribeHandler_TestCase, 'test'))
@@ -268,6 +367,7 @@ def suite():
test_suite.addTest(unittest.makeSuite(DefaultPresenceHandler_TestCase, 'test')) test_suite.addTest(unittest.makeSuite(DefaultPresenceHandler_TestCase, 'test'))
test_suite.addTest(unittest.makeSuite(RootPresenceAvailableHandler_TestCase, 'test')) test_suite.addTest(unittest.makeSuite(RootPresenceAvailableHandler_TestCase, 'test'))
test_suite.addTest(unittest.makeSuite(AccountPresenceAvailableHandler_TestCase, 'test')) test_suite.addTest(unittest.makeSuite(AccountPresenceAvailableHandler_TestCase, 'test'))
test_suite.addTest(unittest.makeSuite(AccountPresenceUnavailableHandler_TestCase, 'test'))
return test_suite return test_suite
if __name__ == '__main__': if __name__ == '__main__':