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)
_account = account.get_account(user_jid, name)
result += self.component.account_manager.get_account_presence_unavailable(
_account)
_account.user.jid, _account)
command_node.setProp("status", STATUS_COMPLETED)
return (None, result)

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

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

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

@@ -84,7 +84,7 @@ class AccountPresenceAvailableHandler(AccountPresenceHandler):
def get_account_presence(self, stanza, lang_class, _account):
_account.default_lang_class = lang_class
return self.component.account_manager.get_account_presence_available(\
_account, lang_class)
stanza.get_from(), _account, lang_class)
class RootPresenceHandler(AccountPresenceHandler):
filter = jabber.get_accounts_root_filter
@@ -123,11 +123,10 @@ class RootPresenceAvailableHandler(RootPresenceHandler, AccountPresenceAvailable
body=motd))
return result
class AccountPresenceUnavailableHandler(AccountPresenceHandler):
def get_account_presence(self, stanza, lang_class, _account):
return self.component.account_manager.get_account_presence_unavailable(\
_account)
stanza.get_from(), _account)
class RootPresenceUnavailableHandler(RootPresenceHandler, AccountPresenceUnavailableHandler):
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",
fields=[Field(field_type="list-multi",
name="delay",
value=[0])])
value=[1])])
result = self.command_manager.apply_command_action(\
info_query,
"http://jabber.org/protocol/admin#shutdown",
@@ -3234,7 +3234,7 @@ class JCLCommandManagerShutdownCommand_TestCase(JCLCommandManagerTestCase):
context_session = self.command_manager.sessions[session_id][1]
self.assertFalse(context_session.has_key("announcement"))
self.assertEquals(context_session["delay"],
["0"])
["1"])
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.account_manager.account_classes = (ExampleAccount,)
x_data = Form("submit")
x_data.add_field(name = "name", \
value = "account1", \
field_type = "text-single")
x_data.add_field(name = "login", \
value = "mylogin", \
field_type = "text-single")
x_data.add_field(name = "password", \
value = "mypassword", \
field_type = "text-private")
x_data.add_field(name = "store_password", \
value = False, \
field_type = "boolean")
x_data.add_field(name = "test_enum", \
value = "choice3", \
field_type = "list-single")
x_data.add_field(name = "test_int", \
value = 43, \
field_type = "text-single")
iq_set = Iq(stanza_type = "set", \
from_jid = "user1@test.com", \
to_jid = "jcl.test.com")
x_data.add_field(name="name",
value="account1",
field_type="text-single")
x_data.add_field(name="login",
value="mylogin",
field_type="text-single")
x_data.add_field(name="password",
value="mypassword",
field_type="text-private")
x_data.add_field(name="store_password",
value=False,
field_type="boolean")
x_data.add_field(name="test_enum",
value="choice3",
field_type="list-single")
x_data.add_field(name="test_int",
value=43,
field_type="text-single")
iq_set = Iq(stanza_type="set",
from_jid="user1@test.com/resource",
to_jid="jcl.test.com")
query = iq_set.new_query("jabber:iq:register")
x_data.as_xml(query, None)
self.comp.handle_set_register(iq_set)
@@ -1334,29 +1334,29 @@ class JCLComponent_TestCase(JCLTestCase):
self.assertTrue(isinstance(iq_result, Iq))
self.assertEquals(iq_result.get_node().prop("type"), "result")
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]
self.assertTrue(isinstance(presence_component, Presence))
self.assertEquals(presence_component.get_from(), "jcl.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")
message = stanza_sent[2]
self.assertTrue(isinstance(message, Message))
self.assertEquals(message.get_from(), "jcl.test.com")
self.assertEquals(message.get_to(), "user1@test.com")
self.assertEquals(message.get_subject(), \
self.assertEquals(message.get_to(), "user1@test.com/resource")
self.assertEquals(message.get_subject(),
_account.get_new_message_subject(Lang.en))
self.assertEquals(message.get_body(), \
self.assertEquals(message.get_body(),
_account.get_new_message_body(Lang.en))
presence_account = stanza_sent[3]
self.assertTrue(isinstance(presence_account, Presence))
self.assertEquals(presence_account.get_from(), "account1@jcl.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")
def test_handle_set_register_new_default_values(self):
@@ -1471,6 +1471,7 @@ class JCLComponent_TestCase(JCLTestCase):
self.assertEquals(len(stanza_sent), 1)
self.assertTrue(isinstance(stanza_sent[0], Iq))
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()
self.assertEquals(stanza_error.get_condition().name,
"not-acceptable")
@@ -1501,6 +1502,7 @@ class JCLComponent_TestCase(JCLTestCase):
self.assertEquals(len(stanza_sent), 1)
self.assertTrue(isinstance(stanza_sent[0], Iq))
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()
self.assertEquals(stanza_error.get_condition().name,
"not-acceptable")
@@ -1727,13 +1729,13 @@ class JCLComponent_TestCase(JCLTestCase):
model.db_disconnect()
self.comp.handle_presence_available(Presence(\
stanza_type="available",
from_jid="user1@test.com",
from_jid="user1@test.com/resource",
to_jid="jcl.test.com"))
presence_sent = self.comp.stream.sent
self.assertEqual(len(presence_sent), 3)
self.assertEqual(len([presence
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]),
3)
self.assertEqual(len([presence
@@ -1790,13 +1792,13 @@ class JCLComponent_TestCase(JCLTestCase):
model.db_disconnect()
self.comp.handle_presence_available(Presence(\
stanza_type="available",
from_jid="user1@test.com",
from_jid="user1@test.com/resource",
to_jid="jcl.test.com"))
presence_sent = self.comp.stream.sent
self.assertEqual(len(presence_sent), 7)
self.assertEqual(len([presence
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]),
7)
self.assertEqual(len([presence
@@ -1888,11 +1890,11 @@ class JCLComponent_TestCase(JCLTestCase):
model.db_disconnect()
self.comp.handle_presence_available(Presence(\
stanza_type="available",
from_jid="user1@test.com",
from_jid="user1@test.com/resource",
to_jid="account11@jcl.test.com"))
presence_sent = self.comp.stream.sent
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.assertTrue(isinstance(presence_sent[0], Presence))
self.assertEqual(presence_sent[0].get_type(), None)
@@ -1915,11 +1917,11 @@ class JCLComponent_TestCase(JCLTestCase):
model.db_disconnect()
self.comp.handle_presence_available(Presence(\
stanza_type="available",
from_jid="user1@test.com",
from_jid="user1@test.com/resource",
to_jid="user1%test.com@jcl.test.com"))
presence_sent = self.comp.stream.sent
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.assertTrue(isinstance(presence_sent[0], Presence))
@@ -1987,7 +1989,7 @@ class JCLComponent_TestCase(JCLTestCase):
model.db_disconnect()
self.comp.handle_presence_available(Presence(\
stanza_type="available",
from_jid="user1@test.com",
from_jid="user1@test.com/resource",
to_jid="account11@jcl.test.com"))
messages_sent = self.comp.stream.sent
self.assertEqual(len(messages_sent), 1)
@@ -1995,7 +1997,7 @@ class JCLComponent_TestCase(JCLTestCase):
self.assertTrue(presence is not None)
self.assertTrue(isinstance(presence, Presence))
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)
def test_handle_presence_available_to_account_live_password_complex(self):
@@ -2016,7 +2018,7 @@ class JCLComponent_TestCase(JCLTestCase):
model.db_disconnect()
self.comp.handle_presence_available(Presence(\
stanza_type="available",
from_jid="user1@test.com",
from_jid="user1@test.com/resource",
to_jid="account11@jcl.test.com"))
messages_sent = self.comp.stream.sent
self.assertEqual(len(messages_sent), 2)
@@ -2031,13 +2033,13 @@ class JCLComponent_TestCase(JCLTestCase):
self.assertTrue(presence is not None)
self.assertTrue(isinstance(presence, Presence))
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(unicode(password_message.get_from_jid()), \
"account11@jcl.test.com")
self.assertEqual(unicode(password_message.get_to_jid()), \
"user1@test.com")
"user1@test.com/resource")
self.assertEqual(password_message.get_subject(), \
"[PASSWORD] Password request")
self.assertEqual(password_message.get_body(), \
@@ -2060,13 +2062,13 @@ class JCLComponent_TestCase(JCLTestCase):
model.db_disconnect()
self.comp.handle_presence_unavailable(Presence(\
stanza_type="unavailable",
from_jid="user1@test.com",
from_jid="user1@test.com/resource",
to_jid="jcl.test.com"))
presence_sent = self.comp.stream.sent
self.assertEqual(len(presence_sent), 3)
self.assertEqual(len([presence
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"]),
3)
self.assertEqual(\
@@ -2126,13 +2128,13 @@ class JCLComponent_TestCase(JCLTestCase):
model.db_disconnect()
self.comp.handle_presence_unavailable(Presence(\
stanza_type="unavailable",
from_jid="user1@test.com",
from_jid="user1@test.com/resource",
to_jid="jcl.test.com"))
presence_sent = self.comp.stream.sent
self.assertEqual(len(presence_sent), 7)
self.assertEqual(len([presence
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"]),
7)
self.assertEqual(len([presence
@@ -2224,11 +2226,11 @@ class JCLComponent_TestCase(JCLTestCase):
model.db_disconnect()
self.comp.handle_presence_unavailable(Presence(\
stanza_type="unavailable",
from_jid="user1@test.com",
from_jid="user1@test.com/resource",
to_jid="account11@jcl.test.com"))
presence_sent = self.comp.stream.sent
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].xpath_eval("@type")[0].get_content(),
@@ -2252,12 +2254,13 @@ class JCLComponent_TestCase(JCLTestCase):
model.db_disconnect()
self.comp.handle_presence_unavailable(Presence(\
stanza_type="unavailable",
from_jid="user1@test.com",
from_jid="user1@test.com/resource",
to_jid="user1%test.com@jcl.test.com"))
presence_sent = self.comp.stream.sent
self.assertEqual(len(presence_sent), 1)
self.assertEqual(presence_sent[0].get_to(), "user1@test.com")
self.assertEqual(presence_sent[0].get_from(), "user1%test.com@jcl.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].xpath_eval("@type")[0].get_content(),
"unavailable")
@@ -3202,6 +3205,18 @@ class AccountManager_TestCase(JCLTestCase):
self.assertEquals(presence.children.name, "show")
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):
"""Test when presence status does not change"""
_account = Account(user=User(jid="user1@test.com"),
@@ -3209,7 +3224,7 @@ class AccountManager_TestCase(JCLTestCase):
jid="account11@jcl.test.com")
_account.status = account.ONLINE
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)
def suite():

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

@@ -55,7 +55,7 @@ class PasswordMessageHandler_TestCase(JCLTestCase):
account12 = ExampleAccount(user=user1,
name="account12",
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",
subject="[PASSWORD]",
body="secret")
@@ -73,7 +73,7 @@ class PasswordMessageHandler_TestCase(JCLTestCase):
account12 = ExampleAccount(user=user1,
name="account12",
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",
subject="[PASSWORD]",
body="secret")
@@ -125,7 +125,7 @@ class PasswordMessageHandler_TestCase(JCLTestCase):
account12 = ExampleAccount(user=user1,
name="account12",
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",
subject="[PASSWORD]",
body="secret")
@@ -152,7 +152,7 @@ class HelpMessageHandler_TestCase(JCLTestCase):
account12 = ExampleAccount(user=user1,
name="account12",
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",
subject="",
body="help")
@@ -167,7 +167,7 @@ class HelpMessageHandler_TestCase(JCLTestCase):
account12 = ExampleAccount(user=user1,
name="account12",
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",
subject="",
body="help dalkjdjhbd")
@@ -212,14 +212,14 @@ class HelpMessageHandler_TestCase(JCLTestCase):
account12 = ExampleAccount(user=user1,
name="account12",
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",
subject="",
body="help")
messages = self.handler.handle(message, Lang.en, account11)
self.assertEquals(len(messages), 1)
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_body(), Lang.en.help_message_body)

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

@@ -31,7 +31,8 @@ from pyxmpp.message import Message
from jcl.jabber.component import JCLComponent
from jcl.jabber.presence import DefaultSubscribeHandler, \
DefaultUnsubscribeHandler, DefaultPresenceHandler, \
RootPresenceAvailableHandler, AccountPresenceAvailableHandler
RootPresenceAvailableHandler, AccountPresenceAvailableHandler, \
AccountPresenceUnavailableHandler
from jcl.model.account import User, LegacyJID, Account
from jcl.lang import Lang
@@ -140,6 +141,29 @@ class RootPresenceAvailableHandler_TestCase(JCLTestCase):
self.assertEquals(result[1].get_from(), "jcl.test.com")
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):
user1 = User(jid="user1@test.com")
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_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):
user1 = User(jid="user1@test.com")
account11 = Account(user=user1,
@@ -261,6 +304,62 @@ class AccountPresenceAvailableHandler_TestCase(JCLTestCase):
self.assertEquals(result[0].get_show(), "dnd")
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():
test_suite = unittest.TestSuite()
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(RootPresenceAvailableHandler_TestCase, 'test'))
test_suite.addTest(unittest.makeSuite(AccountPresenceAvailableHandler_TestCase, 'test'))
test_suite.addTest(unittest.makeSuite(AccountPresenceUnavailableHandler_TestCase, 'test'))
return test_suite
if __name__ == '__main__':