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

Add plugable handlers and define default handlers

Browse Source 
* pluggable handlers for presence_available, presence_unavailable, presence_subscribe, presence_subscribed, message
* define default handlers behavior DefaultSubscribeHandler, DefaultUnsubscribeHandler, DefaultPresenceHandler

darcs-hash:20070523204935-86b55-c45e0631b5694d35d8aac606c1d1f5772bc5f15a.gz
This commit is contained in:
David Rousselie
2007-05-23 22:49:35 +02:00
parent 8b9858a5bf
commit 78ab52627f
5 changed files with 307 additions and 43 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -94,6 +94,10 @@ class JCLComponent(Component, object):
self.queue = Queue(100) self.queue = Queue(100)
self.account_manager = AccountManager(self) self.account_manager = AccountManager(self)
self.msg_handlers = [] self.msg_handlers = []
self.subscribe_handlers = []
self.unsubscribe_handlers = []
self.available_handlers = []
self.unavailable_handlers = []
self.__logger = logging.getLogger("jcl.jabber.JCLComponent") self.__logger = logging.getLogger("jcl.jabber.JCLComponent")
self.lang = lang self.lang = lang
@@ -251,6 +255,18 @@ class JCLComponent(Component, object):
self.send_stanzas(result) self.send_stanzas(result)
return result return result
def apply_registered_behavior(self, handlers, stanza, apply_all = False):
"""Execute handler if their filter method does not return None"""
result = []
self.db_connect()
for handler in handlers:
accounts = handler.filter(stanza)
if accounts is not None:
result += handler.handle(stanza, self.lang, accounts)
self.db_disconnect()
self.send_stanzas(result)
return result
def disco_get_info(self, node, info_query): def disco_get_info(self, node, info_query):
"""Discovery get info handler """Discovery get info handler
""" """
@@ -362,9 +378,10 @@ class JCLComponent(Component, object):
"""Handle presence availability """Handle presence availability
if presence sent to the component ('if not name'), presence is sent to if presence sent to the component ('if not name'), presence is sent to
all accounts for current user. Otherwise, send presence from current account. all accounts for current user. Otherwise, send presence from current account.
""" """
return self.apply_behavior(stanza, \ result = self.apply_registered_behavior(self.available_handlers, stanza)
if result == []:
result = self.apply_behavior(stanza, \
lambda name, from_jid, account_type, lang_class: \ lambda name, from_jid, account_type, lang_class: \
self.account_manager.account_handle_presence_available(name, \ self.account_manager.account_handle_presence_available(name, \
from_jid, \ from_jid, \
@@ -377,13 +394,16 @@ class JCLComponent(Component, object):
lang_class, \ lang_class, \
stanza.get_show()), \ stanza.get_show()), \
send_result = True) send_result = True)
return result
def handle_presence_unavailable(self, stanza): def handle_presence_unavailable(self, stanza):
"""Handle presence unavailability """Handle presence unavailability
""" """
self.__logger.debug("PRESENCE_UNAVAILABLE") self.__logger.debug("PRESENCE_UNAVAILABLE")
return self.apply_behavior(stanza, \ result = self.apply_registered_behavior(self.unavailable_handlers, stanza)
if result == []:
result = self.apply_behavior(stanza, \
lambda name, from_jid, account_type, lang_class: \ lambda name, from_jid, account_type, lang_class: \
self.account_manager.account_handle_presence_unavailable(name, \ self.account_manager.account_handle_presence_unavailable(name, \
from_jid), \ from_jid), \
@@ -392,12 +412,15 @@ class JCLComponent(Component, object):
lambda name, from_jid, account_type, lang_class: \ lambda name, from_jid, account_type, lang_class: \
self.account_manager.root_handle_presence_unavailable(from_jid), \ self.account_manager.root_handle_presence_unavailable(from_jid), \
send_result = True) send_result = True)
return result
def handle_presence_subscribe(self, stanza): def handle_presence_subscribe(self, stanza):
"""Handle subscribe presence from user """Handle subscribe presence from user
""" """
self.__logger.debug("PRESENCE_SUBSCRIBE") self.__logger.debug("PRESENCE_SUBSCRIBE")
return self.apply_behavior(stanza, \ result = self.apply_registered_behavior(self.subscribe_handlers, stanza)
if result == []:
result = self.apply_behavior(stanza, \
lambda name, from_jid, account_type, lang_class: \ lambda name, from_jid, account_type, lang_class: \
self.account_manager.account_handle_presence_subscribe(name, \ self.account_manager.account_handle_presence_subscribe(name, \
from_jid, \ from_jid, \
@@ -408,6 +431,7 @@ class JCLComponent(Component, object):
self.account_manager.root_handle_presence_subscribe(from_jid, \ self.account_manager.root_handle_presence_subscribe(from_jid, \
stanza), \ stanza), \
send_result = True) send_result = True)
return result
def handle_presence_subscribed(self, stanza): def handle_presence_subscribed(self, stanza):
"""Handle subscribed presence from user """Handle subscribed presence from user
@@ -419,7 +443,9 @@ class JCLComponent(Component, object):
"""Handle unsubscribe presence from user """Handle unsubscribe presence from user
""" """
self.__logger.debug("PRESENCE_UNSUBSCRIBE") self.__logger.debug("PRESENCE_UNSUBSCRIBE")
return self.apply_behavior(stanza, \ result = self.apply_registered_behavior(self.unsubscribe_handlers, stanza)
if result == []:
result = self.apply_behavior(stanza, \
lambda name, from_jid, account_type, lang_class: \ lambda name, from_jid, account_type, lang_class: \
self.account_manager.account_handle_presence_unsubscribe(name, \ self.account_manager.account_handle_presence_unsubscribe(name, \
from_jid), \ from_jid), \
@@ -428,6 +454,7 @@ class JCLComponent(Component, object):
lambda name, from_jid, account_type, lang_class: \ lambda name, from_jid, account_type, lang_class: \
[], \ [], \
send_result = True) send_result = True)
return result
def handle_presence_unsubscribed(self, stanza): def handle_presence_unsubscribed(self, stanza):
"""Handle unsubscribed presence from user """Handle unsubscribed presence from user
@@ -444,14 +471,7 @@ class JCLComponent(Component, object):
Handle password response message Handle password response message
""" """
self.__logger.debug("MESSAGE: " + message.get_body()) self.__logger.debug("MESSAGE: " + message.get_body())
result = [] self.apply_registered_behavior(self.msg_handlers, message)
self.db_connect()
for msg_handler in self.msg_handlers:
accounts = msg_handler.filter(message)
if accounts is not None:
result += msg_handler.handle(message, self.lang, accounts)
self.db_disconnect()
self.send_stanzas(result)
return 1 return 1
########################################################################### ###########################################################################
@@ -1093,32 +1113,71 @@ class AccountManager(object):
% (exception))) % (exception)))
return result return result
class MessageHandler(object): class Handler(object):
"""Message handling class""" """handling class"""
def filter(self, message): def filter(self, stanza):
"""Filter account to be processed by the handler """Filter account to be processed by the handler
return all accounts. DB connection might already be opened.""" return all accounts. DB connection might already be opened."""
accounts = Account.select() accounts = Account.select()
return accounts return accounts
def handle(self, message, lang, accounts): def handle(self, stanza, lang, accounts):
"""Apply actions to do on given accounts """Apply actions to do on given accounts
Do nothing by default""" Do nothing by default"""
return [] return []
class PasswordMessageHandler(MessageHandler): class DefaultPresenceHandler(Handler):
"""Handle presence"""
def handle(self, presence, lang, accounts):
"""Return same presence as receive one"""
to_jid = presence.get_to()
from_jid = presence.get_from()
presence.set_to(from_jid)
presence.set_from(to_jid)
return [presence]
class DefaultSubscribeHandler(Handler):
"""Return default response to subscribe queries"""
def handle(self, stanza, lang, accounts):
"""Create subscribe response"""
result = []
result.append(Presence(from_jid = stanza.get_to(), \
to_jid = stanza.get_from(), \
stanza_type = "subscribe"))
result.append(Presence(from_jid = stanza.get_to(), \
to_jid = stanza.get_from(), \
stanza_type = "subscribed"))
return result
class DefaultUnsubscribeHandler(Handler):
"""Return default response to subscribe queries"""
def handle(self, stanza, lang, accounts):
"""Create subscribe response"""
result = []
result.append(Presence(from_jid = stanza.get_to(), \
to_jid = stanza.get_from(), \
stanza_type = "unsubscribe"))
result.append(Presence(from_jid = stanza.get_to(), \
to_jid = stanza.get_from(), \
stanza_type = "unsubscribed"))
return result
class PasswordMessageHandler(Handler):
"""Handle password message""" """Handle password message"""
def __init__(self): def __init__(self):
"""Ḧandler constructor""" """Ḧandler constructor"""
self.password_regexp = re.compile("\[PASSWORD\]") self.password_regexp = re.compile("\[PASSWORD\]")
def filter(self, message): def filter(self, stanza):
"""Return the uniq account associated with a name and user JID. """Return the uniq account associated with a name and user JID.
DB connection might already be opened.""" DB connection might already be opened."""
name = message.get_to().node name = stanza.get_to().node
bare_from_jid = unicode(message.get_from().bare()) bare_from_jid = unicode(stanza.get_from().bare())
accounts = Account.select(\ accounts = Account.select(\
AND(Account.q.name == name, \ AND(Account.q.name == name, \
Account.q.user_jid == bare_from_jid)) Account.q.user_jid == bare_from_jid))
@@ -1128,20 +1187,20 @@ class PasswordMessageHandler(MessageHandler):
if hasattr(_account, 'password') \ if hasattr(_account, 'password') \
and hasattr(_account, 'waiting_password_reply') \ and hasattr(_account, 'waiting_password_reply') \
and (getattr(_account, 'waiting_password_reply') == True) \ and (getattr(_account, 'waiting_password_reply') == True) \
and self.password_regexp.search(message.get_subject()) \ and self.password_regexp.search(stanza.get_subject()) \
is not None: is not None:
return accounts return accounts
else: else:
return None return None
def handle(self, message, lang, accounts): def handle(self, stanza, lang, accounts):
"""Receive password for given account""" """Receive password in stanza (must be a Message) for given account"""
_account = accounts[0] _account = accounts[0]
lang_class = lang.get_lang_class_from_node(message.get_node()) lang_class = lang.get_lang_class_from_node(stanza.get_node())
_account.password = message.get_body() _account.password = stanza.get_body()
_account.waiting_password_reply = False _account.waiting_password_reply = False
return [Message(from_jid = _account.jid, \ return [Message(from_jid = _account.jid, \
to_jid = message.get_from(), \ to_jid = stanza.get_from(), \
stanza_type = "normal", \ stanza_type = "normal", \
subject = lang_class.password_saved_for_session, \ subject = lang_class.password_saved_for_session, \
body = lang_class.password_saved_for_session)] body = lang_class.password_saved_for_session)]

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

@@ -28,6 +28,7 @@ import threading
import time import time
import sys import sys
import os import os
import re
from sqlobject import * from sqlobject import *
from sqlobject.dbconnection import TheURIOpener from sqlobject.dbconnection import TheURIOpener
@@ -40,7 +41,7 @@ from pyxmpp.presence import Presence
from pyxmpp.message import Message from pyxmpp.message import Message
from pyxmpp.jabber.dataforms import Form, Field, Option from pyxmpp.jabber.dataforms import Form, Field, Option
from jcl.jabber.component import JCLComponent, MessageHandler, PasswordMessageHandler from jcl.jabber.component import JCLComponent, Handler, PasswordMessageHandler, DefaultSubscribeHandler, DefaultUnsubscribeHandler, DefaultPresenceHandler
from jcl.model import account from jcl.model import account
from jcl.model.account import Account from jcl.model.account import Account
from jcl.lang import Lang from jcl.lang import Lang
@@ -48,9 +49,9 @@ from jcl.lang import Lang
from jcl.model.tests.account import ExampleAccount, Example2Account from jcl.model.tests.account import ExampleAccount, Example2Account
if sys.platform == "win32": if sys.platform == "win32":
DB_PATH = "/c|/temp/test.db" DB_PATH = "/c|/temp/jcl_test.db"
else: else:
DB_PATH = "/tmp/test.db" DB_PATH = "/tmp/jcl_test.db"
DB_URL = DB_PATH# + "?debug=1&debugThreading=1" DB_URL = DB_PATH# + "?debug=1&debugThreading=1"
class MockStream(object): class MockStream(object):
@@ -125,6 +126,22 @@ class LangExample(Lang):
class en(Lang.en): class en(Lang.en):
type_example_name = "Type Example" type_example_name = "Type Example"
class TestSubscribeHandler(DefaultSubscribeHandler):
def filter(self, message):
if re.compile(".*%.*").match(message.get_to().node):
# return no account because self.handle does not need an account
return []
else:
return None
class TestUnsubscribeHandler(DefaultUnsubscribeHandler):
def filter(self, message):
if re.compile(".*%.*").match(message.get_to().node):
# return no account because self.handle does not need an account
return []
else:
return None
class JCLComponent_TestCase(unittest.TestCase): class JCLComponent_TestCase(unittest.TestCase):
########################################################################### ###########################################################################
# Utility methods # Utility methods
@@ -1398,6 +1415,31 @@ class JCLComponent_TestCase(unittest.TestCase):
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))
def test_handle_presence_available_to_registered_handlers(self):
self.comp.stream = MockStream()
self.comp.stream_class = MockStream
self.comp.available_handlers += [DefaultPresenceHandler()]
account.hub.threadConnection = connectionForURI('sqlite://' + DB_URL)
account11 = Account(user_jid = "user1@test.com", \
name = "account11", \
jid = "account11@jcl.test.com")
account12 = Account(user_jid = "user1@test.com", \
name = "account12", \
jid = "account12@jcl.test.com")
account2 = Account(user_jid = "user2@test.com", \
name = "account2", \
jid = "account2@jcl.test.com")
del account.hub.threadConnection
self.comp.handle_presence_available(Presence(\
stanza_type = "available", \
from_jid = "user1@test.com",\
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.assertTrue(isinstance(presence_sent[0], Presence))
def test_handle_presence_available_to_account_unknown_user(self): def test_handle_presence_available_to_account_unknown_user(self):
self.comp.stream = MockStream() self.comp.stream = MockStream()
self.comp.stream_class = MockStream self.comp.stream_class = MockStream
@@ -1606,6 +1648,33 @@ class JCLComponent_TestCase(unittest.TestCase):
presence_sent[0].xpath_eval("@type")[0].get_content(), \ presence_sent[0].xpath_eval("@type")[0].get_content(), \
"unavailable") "unavailable")
def test_handle_presence_unavailable_to_registered_handlers(self):
self.comp.stream = MockStream()
self.comp.stream_class = MockStream
self.comp.unavailable_handlers += [DefaultPresenceHandler()]
account.hub.threadConnection = connectionForURI('sqlite://' + DB_URL)
account11 = Account(user_jid = "user1@test.com", \
name = "account11", \
jid = "account11@jcl.test.com")
account12 = Account(user_jid = "user1@test.com", \
name = "account12", \
jid = "account12@jcl.test.com")
account2 = Account(user_jid = "user2@test.com", \
name = "account2", \
jid = "account2@jcl.test.com")
del account.hub.threadConnection
self.comp.handle_presence_unavailable(Presence(\
stanza_type = "unavailable", \
from_jid = "user1@test.com",\
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].xpath_eval("@type")[0].get_content(), \
"unavailable")
def test_handle_presence_unavailable_to_account_unknown_user(self): def test_handle_presence_unavailable_to_account_unknown_user(self):
self.comp.stream = MockStream() self.comp.stream = MockStream()
self.comp.stream_class = MockStream self.comp.stream_class = MockStream
@@ -1763,6 +1832,32 @@ class JCLComponent_TestCase(unittest.TestCase):
presence_sent = self.comp.stream.sent presence_sent = self.comp.stream.sent
self.assertEqual(len(presence_sent), 0) self.assertEqual(len(presence_sent), 0)
def test_handle_presence_subscribe_to_registered_handlers(self):
self.comp.stream = MockStream()
self.comp.stream_class = MockStream
self.comp.subscribe_handlers += [DefaultSubscribeHandler()]
account.hub.threadConnection = connectionForURI('sqlite://' + DB_URL)
account11 = Account(user_jid = "user1@test.com", \
name = "account11", \
jid = "account11@jcl.test.com")
account12 = Account(user_jid = "user1@test.com", \
name = "account12", \
jid = "account12@jcl.test.com")
account2 = Account(user_jid = "user2@test.com", \
name = "account2", \
jid = "account2@jcl.test.com")
del account.hub.threadConnection
result = self.comp.handle_presence_subscribe(Presence(\
stanza_type = "subscribe", \
from_jid = "user1@test.com",\
to_jid = "user1%test.com@jcl.test.com"))
sent = self.comp.stream.sent
self.assertEqual(len(sent), 2)
self.assertTrue(type(sent[0]), Presence)
self.assertEquals(sent[0].get_type(), "subscribe")
self.assertTrue(type(sent[1]), Presence)
self.assertEquals(sent[1].get_type(), "subscribed")
def test_handle_presence_subscribed(self): def test_handle_presence_subscribed(self):
self.comp.stream = MockStream() self.comp.stream = MockStream()
self.comp.stream_class = MockStream self.comp.stream_class = MockStream
@@ -1811,6 +1906,38 @@ class JCLComponent_TestCase(unittest.TestCase):
2) 2)
del account.hub.threadConnection del account.hub.threadConnection
def test_handle_presence_unsubscribe_to_registered_handlers(self):
self.comp.stream = MockStream()
self.comp.stream_class = MockStream
self.comp.unsubscribe_handlers += [DefaultUnsubscribeHandler()]
account.hub.threadConnection = connectionForURI('sqlite://' + DB_URL)
account11 = Account(user_jid = "user1@test.com", \
name = "account11", \
jid = "account11@jcl.test.com")
account12 = Account(user_jid = "user1@test.com", \
name = "account12", \
jid = "account12@jcl.test.com")
account2 = Account(user_jid = "user2@test.com", \
name = "account2", \
jid = "account2@jcl.test.com")
del account.hub.threadConnection
self.comp.handle_presence_unsubscribe(Presence(\
stanza_type = "unsubscribe", \
from_jid = "user1@test.com",\
to_jid = "user1%test.com@jcl.test.com"))
presence_sent = self.comp.stream.sent
self.assertEqual(len(presence_sent), 2)
presence = presence_sent[0]
self.assertEqual(presence.get_from(), "user1%test.com@jcl.test.com")
self.assertEqual(presence.get_to(), "user1@test.com")
self.assertEqual(presence.xpath_eval("@type")[0].get_content(), \
"unsubscribe")
presence = presence_sent[1]
self.assertEqual(presence.get_from(), "user1%test.com@jcl.test.com")
self.assertEqual(presence.get_to(), "user1@test.com")
self.assertEqual(presence.xpath_eval("@type")[0].get_content(), \
"unsubscribed")
def test_handle_presence_unsubscribe_to_account_unknown_user(self): def test_handle_presence_unsubscribe_to_account_unknown_user(self):
self.comp.stream = MockStream() self.comp.stream = MockStream()
self.comp.stream_class = MockStream self.comp.stream_class = MockStream
@@ -1836,7 +1963,6 @@ class JCLComponent_TestCase(unittest.TestCase):
3) 3)
del account.hub.threadConnection del account.hub.threadConnection
def test_handle_presence_unsubscribe_to_unknown_account(self): def test_handle_presence_unsubscribe_to_unknown_account(self):
self.comp.stream = MockStream() self.comp.stream = MockStream()
self.comp.stream_class = MockStream self.comp.stream_class = MockStream
@@ -1877,6 +2003,21 @@ class JCLComponent_TestCase(unittest.TestCase):
presence_sent[0].xpath_eval("@type")[0].get_content(), \ presence_sent[0].xpath_eval("@type")[0].get_content(), \
"unavailable") "unavailable")
def test_handle_presence_unsubscribed_to_registered_handler(self):
self.comp.stream = MockStream()
self.comp.stream_class = MockStream
self.comp.handle_presence_unsubscribed(Presence(\
stanza_type = "unsubscribed", \
from_jid = "user1@test.com",\
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].xpath_eval("@type")[0].get_content(), \
"unavailable")
def test_handle_message_password(self): def test_handle_message_password(self):
self.comp.stream = MockStream() self.comp.stream = MockStream()
self.comp.stream_class = MockStream self.comp.stream_class = MockStream
@@ -1983,9 +2124,9 @@ class JCLComponent_TestCase(unittest.TestCase):
self.comp.send_stanzas(None) self.comp.send_stanzas(None)
self.assertEquals(len(self.comp.stream.sent), 0) self.assertEquals(len(self.comp.stream.sent), 0)
class MessageHandler_TestCase(unittest.TestCase): class Handler_TestCase(unittest.TestCase):
def setUp(self): def setUp(self):
self.handler = MessageHandler() self.handler = Handler()
if os.path.exists(DB_PATH): if os.path.exists(DB_PATH):
os.unlink(DB_PATH) os.unlink(DB_PATH)
account.hub.threadConnection = connectionForURI('sqlite://' + DB_URL) account.hub.threadConnection = connectionForURI('sqlite://' + DB_URL)
@@ -2016,6 +2157,66 @@ class MessageHandler_TestCase(unittest.TestCase):
def test_handle(self): def test_handle(self):
self.assertEquals(self.handler.handle(None, None, None), []) self.assertEquals(self.handler.handle(None, None, None), [])
class DefaultSubscribeHandler_TestCase(unittest.TestCase):
def setUp(self):
self.handler = DefaultSubscribeHandler()
def test_handle(self):
presence = Presence(from_jid = "user1@test.com", \
to_jid = "user1%test.com@jcl.test.com", \
stanza_type = "subscribe")
result = self.handler.handle(presence, None, [])
self.assertEquals(len(result), 2)
self.assertEquals(result[0].get_to(), "user1@test.com")
self.assertEquals(result[0].get_from(), "user1%test.com@jcl.test.com")
self.assertEquals(result[0].get_type(), "subscribe")
self.assertEquals(result[1].get_to(), "user1@test.com")
self.assertEquals(result[1].get_from(), "user1%test.com@jcl.test.com")
self.assertEquals(result[1].get_type(), "subscribed")
class DefaultUnsubscribeHandler_TestCase(unittest.TestCase):
def setUp(self):
self.handler = DefaultUnsubscribeHandler()
def test_handle(self):
presence = Presence(from_jid = "user1@test.com", \
to_jid = "user1%test.com@jcl.test.com", \
stanza_type = "unsubscribe")
result = self.handler.handle(presence, None, [])
self.assertEquals(len(result), 2)
self.assertEquals(result[0].get_to(), "user1@test.com")
self.assertEquals(result[0].get_from(), "user1%test.com@jcl.test.com")
self.assertEquals(result[0].get_type(), "unsubscribe")
self.assertEquals(result[1].get_to(), "user1@test.com")
self.assertEquals(result[1].get_from(), "user1%test.com@jcl.test.com")
self.assertEquals(result[1].get_type(), "unsubscribed")
class DefaultPresenceHandler_TestCase(unittest.TestCase):
def setUp(self):
self.handler = DefaultPresenceHandler()
def test_handle_away(self):
presence = Presence(from_jid = "user1@test.com", \
to_jid = "user1%test.com@jcl.test.com", \
stanza_type = "available", \
show = "away")
result = self.handler.handle(presence, None, [])
self.assertEquals(len(result), 1)
self.assertEquals(result[0].get_to(), "user1@test.com")
self.assertEquals(result[0].get_from(), "user1%test.com@jcl.test.com")
self.assertEquals(result[0].get_type(), None)
self.assertEquals(result[0].get_show(), "away")
def test_handle_offline(self):
presence = Presence(from_jid = "user1@test.com", \
to_jid = "user1%test.com@jcl.test.com", \
stanza_type = "unavailable")
result = self.handler.handle(presence, None, [])
self.assertEquals(len(result), 1)
self.assertEquals(result[0].get_to(), "user1@test.com")
self.assertEquals(result[0].get_from(), "user1%test.com@jcl.test.com")
self.assertEquals(result[0].get_type(), "unavailable")
class PasswordMessageHandler_TestCase(unittest.TestCase): class PasswordMessageHandler_TestCase(unittest.TestCase):
def setUp(self): def setUp(self):
self.handler = PasswordMessageHandler() self.handler = PasswordMessageHandler()
@@ -2129,7 +2330,10 @@ class PasswordMessageHandler_TestCase(unittest.TestCase):
def suite(): def suite():
suite = unittest.TestSuite() suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(JCLComponent_TestCase, 'test')) suite.addTest(unittest.makeSuite(JCLComponent_TestCase, 'test'))
suite.addTest(unittest.makeSuite(MessageHandler_TestCase, 'test')) suite.addTest(unittest.makeSuite(Handler_TestCase, 'test'))
suite.addTest(unittest.makeSuite(DefaultSubscribeHandler_TestCase, 'test'))
suite.addTest(unittest.makeSuite(DefaultUnsubscribeHandler_TestCase, 'test'))
suite.addTest(unittest.makeSuite(DefaultPresenceHandler_TestCase, 'test'))
suite.addTest(unittest.makeSuite(PasswordMessageHandler_TestCase, 'test')) suite.addTest(unittest.makeSuite(PasswordMessageHandler_TestCase, 'test'))
return suite return suite

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

@@ -41,9 +41,9 @@ from jcl.model.tests.account import ExampleAccount, Example2Account
from jcl.jabber.tests.component import JCLComponent_TestCase, MockStream from jcl.jabber.tests.component import JCLComponent_TestCase, MockStream
if sys.platform == "win32": if sys.platform == "win32":
DB_PATH = "/c|/temp/test.db" DB_PATH = "/c|/temp/jcl_test.db"
else: else:
DB_PATH = "/tmp/test.db" DB_PATH = "/tmp/jcl_test.db"
DB_URL = DB_PATH #+ "?debug=1&debugThreading=1" DB_URL = DB_PATH #+ "?debug=1&debugThreading=1"
class FeederComponent_TestCase(JCLComponent_TestCase): class FeederComponent_TestCase(JCLComponent_TestCase):

12
src/jcl/model/tests/account.py
View File

@@ -31,6 +31,12 @@ from jcl.jabber.error import FieldError
from jcl.model import account from jcl.model import account
from jcl.model.account import Account, PresenceAccount from jcl.model.account import Account, PresenceAccount
if sys.platform == "win32":
DB_PATH = "/c|/temp/jcl_test.db"
else:
DB_PATH = "/tmp/jcl_test.db"
DB_URL = DB_PATH# + "?debug=1&debugThreading=1"
class ExampleAccount(Account): class ExampleAccount(Account):
login = StringCol(default = "") login = StringCol(default = "")
password = StringCol(default = None) password = StringCol(default = None)
@@ -110,12 +116,6 @@ class PresenceAccountExample(PresenceAccount):
lambda : 43)] lambda : 43)]
get_register_fields = classmethod(_get_register_fields) get_register_fields = classmethod(_get_register_fields)
if sys.platform == "win32":
DB_PATH = "/c|/temp/test.db"
else:
DB_PATH = "/tmp/test.db"
DB_URL = DB_PATH# + "?debug=1&debugThreading=1"
class AccountModule_TestCase(unittest.TestCase): class AccountModule_TestCase(unittest.TestCase):
def test_default_post_func(self): def test_default_post_func(self):
result = account.default_post_func("test", None) result = account.default_post_func("test", None)

1
src/jcl/runner.py
View File

@@ -143,6 +143,7 @@ class JCLRunner(object):
commandline_args = self.__configure_commandline_args(shortopts, longopts, cleanopts) commandline_args = self.__configure_commandline_args(shortopts, longopts, cleanopts)
if commandline_args.has_key("debug") or commandline_args.has_key("d"): if commandline_args.has_key("debug") or commandline_args.has_key("d"):
self.debug = True self.debug = True
self.logger.debug("Debug activated")
self.__apply_configfile(commandline_args, cleanopts) self.__apply_configfile(commandline_args, cleanopts)
self.__apply_commandline_args(commandline_args, cleanopts) self.__apply_commandline_args(commandline_args, cleanopts)