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

Some refactoring in presence module

Browse Source 
darcs-hash:20080513174207-86b55-fddead25458026a8ad8de05455a6e1070f19b3ce.gz
This commit is contained in:
David Rousselie
2008-05-13 19:42:07 +02:00
parent 0ddf21516f
commit 5b868287d5
5 changed files with 126 additions and 161 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -74,7 +74,7 @@ class CommandError(Exception):
""" """
Exception.__init__(self) Exception.__init__(self)
self.type = error_type self.type = error_type
class CommandManager(object): class CommandManager(object):
"""Handle Ad-Hoc commands""" """Handle Ad-Hoc commands"""
@@ -110,7 +110,7 @@ class CommandManager(object):
for command_name in self.commands.keys(): for command_name in self.commands.keys():
(must_be_admin, to_jid_re) = self.commands[command_name] (must_be_admin, to_jid_re) = self.commands[command_name]
if to_jid_re.match(unicode(to_jid)) and \ if to_jid_re.match(unicode(to_jid)) and \
(not must_be_admin or (not must_be_admin or
(must_be_admin and self.component.is_admin(jid))): (must_be_admin and self.component.is_admin(jid))):
command_desc = self.get_command_desc(command_name, command_desc = self.get_command_desc(command_name,
lang_class) lang_class)
@@ -274,7 +274,10 @@ class CommandManager(object):
"feature-not-implemented")] "feature-not-implemented")]
except CommandError, error: except CommandError, error:
return [info_query.make_error_response(error.type)] return [info_query.make_error_response(error.type)]
except Exception: except Exception, exception:
self.__logger.error("Unknown error while executing "
+ str(short_node) + " command: ",
exc_info=True)
return [info_query.make_error_response("service-unavailable")] return [info_query.make_error_response("service-unavailable")]
def add_actions(self, command_node, actions, default_action_idx=0): def add_actions(self, command_node, actions, default_action_idx=0):
@@ -700,7 +703,7 @@ class JCLCommandManager(CommandManager):
for account_name in session_context["account_names"]: for account_name in session_context["account_names"]:
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.send_presence_unavailable( result += self.component.account_manager.get_account_presence_unavailable(
_account) _account)
command_node.setProp("status", STATUS_COMPLETED) command_node.setProp("status", STATUS_COMPLETED)
return (None, result) return (None, result)
@@ -1248,12 +1251,13 @@ class JCLCommandManager(CommandManager):
to_jid=user.jid, to_jid=user.jid,
body=announcement)) body=announcement))
command_node.setProp("status", STATUS_COMPLETED) command_node.setProp("status", STATUS_COMPLETED)
def delayed_restart(self, delay): def delayed_shutdown(self, delay):
threading.Event().wait(delay) threading.Event().wait(delay)
self.component.running = False self.component.running = False
restart_thread = threading.Thread(target=lambda : delayed_restart(self, delay), shutdown_thread = threading.Thread(\
name="TimerThread") target=lambda : delayed_shutdown(self, delay),
restart_thread.start() name="TimerThread")
shutdown_thread.start()
return (None, result) return (None, result)
def execute_get_last_error_1(self, info_query, session_context, def execute_get_last_error_1(self, info_query, session_context,
@@ -1321,4 +1325,3 @@ class CommandDiscoGetItemsHandler(DiscoHandler):
to_jid=info_query.get_to(), to_jid=info_query.get_to(),
disco_items=disco_obj, disco_items=disco_obj,
lang_class=lang_class)] lang_class=lang_class)]

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

@@ -218,11 +218,7 @@ class AccountManager(object):
try: try:
getattr(_account, "populate_handler")() getattr(_account, "populate_handler")()
except Exception, exception: except Exception, exception:
typ, value, stack = sys.exc_info() self.__logger.error("Error in timer thread:", exc_info=True)
self.__logger.error(\
"Error in timer thread\n%s\n%s"
% (exception, "".join(traceback.format_exception
(typ, value, stack, 5))))
result.extend(self.send_error_from_account(_account, result.extend(self.send_error_from_account(_account,
exception)) exception))
@@ -337,27 +333,85 @@ class AccountManager(object):
return [] return []
###### presence generic handlers ###### ###### presence generic handlers ######
def send_presence_all(self, presence): def get_presence_all(self, presence):
"""Send presence to all account. Optimized to use only one sql """Send presence to all account. Optimized to use only one sql
request""" request"""
result = [] result = []
model.db_connect() model.db_connect()
# Explicit reference to account table (clauseTables) to use
# "user_jid" column with Account subclasses
for user in account.get_all_users(): for user in account.get_all_users():
result.extend(self.send_presence(self.component.jid, result.extend(self.get_presence(self.component.jid,
user.jid, user.jid,
presence)) presence))
for _account in account.get_all_accounts(): for _account in account.get_all_accounts():
result.extend(getattr(self, "send_presence_" + result.extend(getattr(self, "get_account_presence_" +
presence)(_account)) presence)(_account))
model.db_disconnect() model.db_disconnect()
return result return result
def get_root_presence(self, to_jid, presence_type,
show=None, status=None):
result = self.get_presence(self.component.jid, to_jid,
presence_type, show=show,
status=status)
for legacy_jid in account.get_legacy_jids(unicode(to_jid.bare())):
result.append(Presence(from_jid=legacy_jid.jid,
to_jid=to_jid,
show=show,
status=status,
stanza_type=presence_type))
return result
def get_presence(self, from_jid, to_jid, presence_type,
status=None, show=None):
"""Send presence stanza"""
return [Presence(from_jid=from_jid,
to_jid=to_jid,
status=status,
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):
"""Send unavailable presence to account's user"""
_account.status = account.OFFLINE
return self.get_presence(from_jid=_account.jid,
to_jid=_account.user.jid,
presence_type="unavailable")
def get_account_presence_available(self, _account, lang_class):
"""Send available presence to account's user and ask for password
if necessary"""
result = []
model.db_connect()
_account.default_lang_class = lang_class
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
result.extend(self.get_presence(from_jid=_account.jid,
to_jid=_account.user.jid,
status=_account.status_msg,
show=_account.status,
presence_type="available"))
if hasattr(_account, 'store_password') \
and hasattr(_account, 'password') \
and _account.store_password == False \
and old_status == account.OFFLINE \
and _account.password == None :
result.extend(self.ask_password(_account, lang_class))
model.db_disconnect()
return result
def probe_all_accounts_presence(self): def probe_all_accounts_presence(self):
"""Send presence probe to all registered accounts""" """Send presence probe to all registered accounts"""
return self.send_presence_all("probe") return self.get_presence_all("probe")
###### Utils methods ###### ###### Utils methods ######
def list_accounts(self, bare_from_jid, account_class=None, def list_accounts(self, bare_from_jid, account_class=None,
@@ -469,78 +523,6 @@ 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 send_presence_probe(self, _account):
"""Send presence probe to account's user"""
return [Presence(from_jid=_account.jid,
to_jid=_account.user.jid,
stanza_type="probe")]
def send_presence_unavailable(self, _account):
"""Send unavailable presence to account's user"""
model.db_connect()
_account.status = account.OFFLINE
result = [Presence(from_jid=_account.jid,
to_jid=_account.user.jid,
stanza_type="unavailable")]
model.db_disconnect()
return result
def send_root_presence(self, to_jid, presence_type,
show=None, status=None):
result = self.send_presence(self.component.jid, to_jid,
presence_type, show=show,
status=status)
result.extend(self.send_root_presence_legacy(to_jid,
presence_type,
show=show,
status=status))
return result
def send_presence(self, from_jid, to_jid, presence_type, status=None, show=None):
"""Send presence stanza"""
return [Presence(from_jid=from_jid,
to_jid=to_jid,
status=status,
show=show,
stanza_type=presence_type)]
def send_presence_available(self, _account, show, lang_class):
"""Send available presence to account's user and ask for password
if necessary"""
result = []
model.db_connect()
_account.default_lang_class = lang_class
old_status = _account.status
if show is None:
_account.status = account.ONLINE
else:
_account.status = show
result.append(Presence(from_jid=_account.jid,
to_jid=_account.user.jid,
status=_account.status_msg,
show=show,
stanza_type="available"))
if hasattr(_account, 'store_password') \
and hasattr(_account, 'password') \
and _account.store_password == False \
and old_status == account.OFFLINE \
and _account.password == None :
result.extend(self.ask_password(_account, lang_class))
model.db_disconnect()
return result
def send_root_presence_legacy(self, to_jid, presence_type,
status=None, show=None):
"""Send presence from legacy JID"""
result = []
for legacy_jid in account.get_legacy_jids(unicode(to_jid.bare())):
result.append(Presence(from_jid=legacy_jid.jid,
to_jid=to_jid,
show=show,
status=status,
stanza_type=presence_type))
return result
def ask_password(self, _account, lang_class): def ask_password(self, _account, lang_class):
"""Send a Jabber message to ask for account password """Send a Jabber message to ask for account password
""" """
@@ -685,7 +667,7 @@ class JCLComponent(Component, object):
self.running = False self.running = False
if self.stream and not self.stream.eof \ if self.stream and not self.stream.eof \
and self.stream.socket is not None: and self.stream.socket is not None:
presences = self.account_manager.send_presence_all("unavailable") presences = self.account_manager.get_presence_all("unavailable")
self.send_stanzas(presences) self.send_stanzas(presences)
self.wait_event.set() self.wait_event.set()
timer_thread.join(JCLComponent.timeout) timer_thread.join(JCLComponent.timeout)
@@ -718,10 +700,7 @@ class JCLComponent(Component, object):
self.handle_tick() self.handle_tick()
self.__logger.debug(".") self.__logger.debug(".")
except Exception, exception: except Exception, exception:
type, value, stack = sys.exc_info() self.__logger.error("Error in timer thread:", exc_info=True)
self.__logger.error("Error in timer thread\n%s\n%s"
% (exception, "".join(traceback.format_exception
(type, value, stack, 5))))
self.queue.put(exception) self.queue.put(exception)
self.__logger.info("Timer thread terminated...") self.__logger.info("Timer thread terminated...")
@@ -853,11 +832,9 @@ class JCLComponent(Component, object):
result += handler_result result += handler_result
break break
except Exception, e: except Exception, e:
error_type, value, stack = sys.exc_info()
self.__logger.error("Error with handler " + str(handler) + self.__logger.error("Error with handler " + str(handler) +
" with " + str(stanza) + "\n%s\n%s" " with " + str(stanza) + ": ",
% (e, "".join(traceback.format_exception exc_info=True)
(error_type, value, stack, 5))))
result += [Message(from_jid=stanza.get_to(), result += [Message(from_jid=stanza.get_to(),
to_jid=stanza.get_from(), to_jid=stanza.get_from(),
stanza_type="error", stanza_type="error",
@@ -1067,15 +1044,9 @@ class JCLComponent(Component, object):
action) action)
self.send_stanzas(result) self.send_stanzas(result)
except: except:
type, value, stack = sys.exc_info()
self.__logger.error("Error in command " + str(command_node) + self.__logger.error("Error in command " + str(command_node) +
" with " + str(info_query) + "\n%s" " with " + str(info_query) + ":",
% ("".join(traceback.format_exception exc_info=True)
(type, value, stack, 5))))
print("Error in command " + str(command_node) +
" with " + str(info_query) + "\n%s"
% ("".join(traceback.format_exception
(type, value, stack, 5))))
return 1 return 1
########################################################################### ###########################################################################
@@ -1084,10 +1055,7 @@ class JCLComponent(Component, object):
def send_error(self, _account, exception): def send_error(self, _account, exception):
""" """ """ """
self.send_stanzas(self.account_manager.send_error_from_account(_account, exception)) self.send_stanzas(self.account_manager.send_error_from_account(_account, exception))
type, value, stack = sys.exc_info() self.__logger.debug("Error: ", exc_info=True)
self.__logger.debug("Error: %s\n%s"
% (exception, "".join(traceback.format_exception
(type, value, stack, 5))))
def get_config_parameter(self, section, parameter): def get_config_parameter(self, section, parameter):
if self.config is not None \ if self.config is not None \
@@ -1159,4 +1127,3 @@ class JCLComponent(Component, object):
Called regularly Called regularly
""" """
raise NotImplementedError raise NotImplementedError

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

@@ -69,7 +69,7 @@ class DefaultUnsubscribeHandler(Handler):
class AccountPresenceHandler(Handler): class AccountPresenceHandler(Handler):
filter = jabber.get_account_filter filter = jabber.get_account_filter
def get_account_presence(self, stanza, lang_class, _account): def get_account_presence(self, stanza, lang_class, _account):
raise NotImplemented raise NotImplemented
@@ -82,15 +82,8 @@ class AccountPresenceHandler(Handler):
class AccountPresenceAvailableHandler(AccountPresenceHandler): class AccountPresenceAvailableHandler(AccountPresenceHandler):
def get_account_presence(self, stanza, lang_class, _account): def get_account_presence(self, stanza, lang_class, _account):
show_status = account.ONLINE return self.component.account_manager.get_account_presence_available(\
if _account.error is not None: _account, lang_class)
show_status = account.DND
elif not _account.enabled:
show_status = account.XA
return self.component.account_manager.send_presence_available(\
_account,
show_status,
lang_class)
class RootPresenceHandler(AccountPresenceHandler): class RootPresenceHandler(AccountPresenceHandler):
filter = jabber.get_accounts_root_filter filter = jabber.get_accounts_root_filter
@@ -109,15 +102,16 @@ class RootPresenceHandler(AccountPresenceHandler):
if accounts_length > 0: if accounts_length > 0:
result.extend(self.get_root_presence(stanza, lang_class, accounts_length)) result.extend(self.get_root_presence(stanza, lang_class, accounts_length))
return result return result
class RootPresenceAvailableHandler(RootPresenceHandler, AccountPresenceAvailableHandler): class RootPresenceAvailableHandler(RootPresenceHandler, AccountPresenceAvailableHandler):
def get_root_presence(self, stanza, lang_class, nb_accounts): def get_root_presence(self, stanza, lang_class, nb_accounts):
from_jid = stanza.get_from() from_jid = stanza.get_from()
result = self.component.account_manager.send_root_presence(from_jid, result = self.component.account_manager.get_root_presence(\
"available", from_jid,
"online", "available",
str(nb_accounts) + "online",
lang_class.message_status) str(nb_accounts) +
lang_class.message_status)
user = account.get_user(unicode(from_jid.bare())) user = account.get_user(unicode(from_jid.bare()))
if not user.has_received_motd: if not user.has_received_motd:
user.has_received_motd = True user.has_received_motd = True
@@ -127,16 +121,17 @@ class RootPresenceAvailableHandler(RootPresenceHandler, AccountPresenceAvailable
to_jid=from_jid, to_jid=from_jid,
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.send_presence_unavailable(_account) return self.component.account_manager.get_account_presence_unavailable(\
_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):
return self.component.account_manager.send_root_presence(stanza.get_from(), return self.component.account_manager.get_root_presence(\
"unavailable") stanza.get_from(), "unavailable")
class AccountPresenceSubscribeHandler(Handler): class AccountPresenceSubscribeHandler(Handler):
"""""" """"""

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

@@ -423,14 +423,14 @@ class CommandManager_TestCase(unittest.TestCase):
def test_multi_step_command_error_in_command(self): def test_multi_step_command_error_in_command(self):
""" """
Test if the multi steps method catch the CommandError exception Test if the multi steps method catch the CommandError exception
and translate it into an IQ error and translate it into an IQ error
""" """
self.command_manager = MockCommandManager() self.command_manager = MockCommandManager()
def execute_command1(info_query, session_context, def execute_command1(info_query, session_context,
command_node, lang_class): command_node, lang_class):
raise CommandError("feature-not-implemented") raise CommandError("feature-not-implemented")
self.command_manager.__dict__["execute_command1_1"] = execute_command1 self.command_manager.__dict__["execute_command1_1"] = execute_command1
info_query = Iq(stanza_type="set", info_query = Iq(stanza_type="set",
from_jid="user@test.com", from_jid="user@test.com",
@@ -442,7 +442,7 @@ class CommandManager_TestCase(unittest.TestCase):
info_query, "command1", None) info_query, "command1", None)
result_iq = result[0].xmlnode result_iq = result[0].xmlnode
self.assertTrue(jcl.tests.is_xml_equal(\ self.assertTrue(jcl.tests.is_xml_equal(\
u"<iq from='" + unicode(self.command_manager.component.jid) u"<iq from='" + unicode(self.command_manager.component.jid)
+ "' to='user@test.com' type='error' " + "' to='user@test.com' type='error' "
+ "xmlns='http://pyxmpp.jabberstudio.org/xmlns/common'>" + "xmlns='http://pyxmpp.jabberstudio.org/xmlns/common'>"
+ "<command xmlns='http://jabber.org/protocol/commands'" + "<command xmlns='http://jabber.org/protocol/commands'"
@@ -454,14 +454,14 @@ class CommandManager_TestCase(unittest.TestCase):
def test_multi_step_command_unknown_error_in_command(self): def test_multi_step_command_unknown_error_in_command(self):
""" """
Test if the multi steps method catch the CommandError exception Test if the multi steps method catch the CommandError exception
and translate it into an IQ error and translate it into an IQ error
""" """
self.command_manager = MockCommandManager() self.command_manager = MockCommandManager()
def execute_command1(info_query, session_context, def execute_command1(info_query, session_context,
command_node, lang_class): command_node, lang_class):
raise Exception("error") raise Exception("error")
self.command_manager.__dict__["execute_command1_1"] = execute_command1 self.command_manager.__dict__["execute_command1_1"] = execute_command1
info_query = Iq(stanza_type="set", info_query = Iq(stanza_type="set",
from_jid="user@test.com", from_jid="user@test.com",
@@ -473,7 +473,7 @@ class CommandManager_TestCase(unittest.TestCase):
info_query, "command1", None) info_query, "command1", None)
result_iq = result[0].xmlnode result_iq = result[0].xmlnode
self.assertTrue(jcl.tests.is_xml_equal(\ self.assertTrue(jcl.tests.is_xml_equal(\
u"<iq from='" + unicode(self.command_manager.component.jid) u"<iq from='" + unicode(self.command_manager.component.jid)
+ "' to='user@test.com' type='error' " + "' to='user@test.com' type='error' "
+ "xmlns='http://pyxmpp.jabberstudio.org/xmlns/common'>" + "xmlns='http://pyxmpp.jabberstudio.org/xmlns/common'>"
+ "<command xmlns='http://jabber.org/protocol/commands'" + "<command xmlns='http://jabber.org/protocol/commands'"
@@ -3005,10 +3005,10 @@ class JCLCommandManagerRestartCommand_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]),
Field(field_type="text-multi", Field(field_type="text-multi",
name="announcement", name="announcement",
value=["service will be restarted in 0 second"])]) value=["service will be restarted in 1 second"])])
result = self.command_manager.apply_command_action(\ result = self.command_manager.apply_command_action(\
info_query, info_query,
"http://jabber.org/protocol/admin#restart", "http://jabber.org/protocol/admin#restart",
@@ -3036,20 +3036,20 @@ class JCLCommandManagerRestartCommand_TestCase(JCLCommandManagerTestCase):
u"<message from='" + unicode(self.comp.jid) + "' " u"<message from='" + unicode(self.comp.jid) + "' "
+ "xmlns=\"http://pyxmpp.jabberstudio.org/xmlns/common\" " + "xmlns=\"http://pyxmpp.jabberstudio.org/xmlns/common\" "
+ "to='test1@test.com'>" + "to='test1@test.com'>"
+ "<body>service will be restarted in 0 second</body></message>", + "<body>service will be restarted in 1 second</body></message>",
result_iq, True, test_sibling=False)) result_iq, True, test_sibling=False))
result_iq = result[2].xmlnode result_iq = result[2].xmlnode
self.assertTrue(jcl.tests.is_xml_equal(\ self.assertTrue(jcl.tests.is_xml_equal(\
u"<message from='" + unicode(self.comp.jid) + "' " u"<message from='" + unicode(self.comp.jid) + "' "
+ "xmlns=\"http://pyxmpp.jabberstudio.org/xmlns/common\" " + "xmlns=\"http://pyxmpp.jabberstudio.org/xmlns/common\" "
+ "to='test2@test.com'>" + "to='test2@test.com'>"
+ "<body>service will be restarted in 0 second</body></message>", + "<body>service will be restarted in 1 second</body></message>",
result_iq, True, test_sibling=False)) result_iq, True, test_sibling=False))
context_session = self.command_manager.sessions[session_id][1] context_session = self.command_manager.sessions[session_id][1]
self.assertEquals(context_session["announcement"], self.assertEquals(context_session["announcement"],
["service will be restarted in 0 second"]) ["service will be restarted in 1 second"])
self.assertEquals(context_session["delay"], self.assertEquals(context_session["delay"],
["0"]) ["1"])
def test_execute_restart_no_announcement(self): def test_execute_restart_no_announcement(self):
session_id = self._common_execute_restart() session_id = self._common_execute_restart()
@@ -3059,7 +3059,7 @@ class JCLCommandManagerRestartCommand_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#restart", "http://jabber.org/protocol/admin#restart",
@@ -3085,7 +3085,7 @@ class JCLCommandManagerRestartCommand_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 JCLCommandManagerShutdownCommand_TestCase(JCLCommandManagerTestCase): class JCLCommandManagerShutdownCommand_TestCase(JCLCommandManagerTestCase):
""" """
@@ -3154,10 +3154,10 @@ 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]),
Field(field_type="text-multi", Field(field_type="text-multi",
name="announcement", name="announcement",
value=["service will be shutdown in 0 second"])]) value=["service will be shutdown in 1 second"])])
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",
@@ -3185,20 +3185,20 @@ class JCLCommandManagerShutdownCommand_TestCase(JCLCommandManagerTestCase):
u"<message from='" + unicode(self.comp.jid) + "' " u"<message from='" + unicode(self.comp.jid) + "' "
+ "xmlns=\"http://pyxmpp.jabberstudio.org/xmlns/common\" " + "xmlns=\"http://pyxmpp.jabberstudio.org/xmlns/common\" "
+ "to='test1@test.com'>" + "to='test1@test.com'>"
+ "<body>service will be shutdown in 0 second</body></message>", + "<body>service will be shutdown in 1 second</body></message>",
result_iq, True, test_sibling=False)) result_iq, True, test_sibling=False))
result_iq = result[2].xmlnode result_iq = result[2].xmlnode
self.assertTrue(jcl.tests.is_xml_equal(\ self.assertTrue(jcl.tests.is_xml_equal(\
u"<message from='" + unicode(self.comp.jid) + "' " u"<message from='" + unicode(self.comp.jid) + "' "
+ "xmlns=\"http://pyxmpp.jabberstudio.org/xmlns/common\" " + "xmlns=\"http://pyxmpp.jabberstudio.org/xmlns/common\" "
+ "to='test2@test.com'>" + "to='test2@test.com'>"
+ "<body>service will be shutdown in 0 second</body></message>", + "<body>service will be shutdown in 1 second</body></message>",
result_iq, True, test_sibling=False)) result_iq, True, test_sibling=False))
context_session = self.command_manager.sessions[session_id][1] context_session = self.command_manager.sessions[session_id][1]
self.assertEquals(context_session["announcement"], self.assertEquals(context_session["announcement"],
["service will be shutdown in 0 second"]) ["service will be shutdown in 1 second"])
self.assertEquals(context_session["delay"], self.assertEquals(context_session["delay"],
["0"]) ["1"])
def test_execute_shutdown_no_announcement(self): def test_execute_shutdown_no_announcement(self):
session_id = self._common_execute_shutdown() session_id = self._common_execute_shutdown()
@@ -3321,8 +3321,8 @@ def suite():
return test_suite return test_suite
if __name__ == '__main__': if __name__ == '__main__':
logger = logging.getLogger()
logger.addHandler(logging.StreamHandler())
if '-v' in sys.argv: if '-v' in sys.argv:
logger = logging.getLogger()
logger.addHandler(logging.StreamHandler())
logger.setLevel(logging.INFO) logger.setLevel(logging.INFO)
unittest.main(defaultTest='suite') unittest.main(defaultTest='suite')

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

@@ -3071,7 +3071,7 @@ class AccountManager_TestCase(JCLTestCase):
None) None)
self.account_manager = self.comp.account_manager self.account_manager = self.comp.account_manager
def test_send_presence_all(self): def test_get_presence_all(self):
user1 = User(jid="test1@test.com") user1 = User(jid="test1@test.com")
account11 = Account(user=user1, account11 = Account(user=user1,
name="account11", name="account11",
@@ -3086,7 +3086,7 @@ class AccountManager_TestCase(JCLTestCase):
account22 = Account(user=user2, account22 = Account(user=user2,
name="account22", name="account22",
jid="account22@jcl.test.com") jid="account22@jcl.test.com")
result = self.account_manager.send_presence_all("unavailable") result = self.account_manager.get_presence_all("unavailable")
self.assertEquals(len(result), 6) self.assertEquals(len(result), 6)
self.assertEquals(result[0].get_from(), "jcl.test.com") self.assertEquals(result[0].get_from(), "jcl.test.com")
self.assertEquals(result[0].get_to(), "test1@test.com") self.assertEquals(result[0].get_to(), "test1@test.com")