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

'set-motd' ad-hoc command implementation

Browse Source 
darcs-hash:20070819112934-86b55-3bd6af965e05e4a5e902e84b7d378f70ae7ac047.gz
This commit is contained in:
David Rousselie
2007-08-19 13:29:34 +02:00
parent 70f66e6e8e
commit 08cb317257
15 changed files with 1231 additions and 744 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
conf/jcl.conf
View File

@@ -17,5 +17,6 @@ db_url: %(type)s://%(host)s%(name)s
[component] [component]
pid_file: /var/run/jabber/jcl.pid pid_file: /var/run/jabber/jcl.pid
#motd: "Message of the day"

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

@@ -25,6 +25,8 @@ import re
import datetime import datetime
import logging import logging
from sqlobject.sqlbuilder import AND
from pyxmpp.jid import JID from pyxmpp.jid import JID
from pyxmpp.jabber.disco import DiscoInfo, DiscoItems, DiscoItem, DiscoIdentity from pyxmpp.jabber.disco import DiscoInfo, DiscoItems, DiscoItem, DiscoIdentity
from pyxmpp.jabber.dataforms import Form, Field from pyxmpp.jabber.dataforms import Form, Field
@@ -32,7 +34,7 @@ from pyxmpp.message import Message
from jcl.jabber.disco import DiscoHandler, RootDiscoGetInfoHandler from jcl.jabber.disco import DiscoHandler, RootDiscoGetInfoHandler
from jcl.model import account from jcl.model import account
from jcl.model.account import Account from jcl.model.account import Account, User
COMMAND_NS = "http://jabber.org/protocol/commands" COMMAND_NS = "http://jabber.org/protocol/commands"
@@ -364,7 +366,7 @@ class JCLCommandManager(CommandManager):
accounts = account.get_all_accounts(filter=filter, limit=limit) accounts = account.get_all_accounts(filter=filter, limit=limit)
accounts_labels = [] accounts_labels = []
for _account in accounts: for _account in accounts:
accounts_labels += [_account.user_jid + " (" + _account.name accounts_labels += [_account.user.jid + " (" + _account.name
+ " " + str(_account.__class__.__name__) + ")"] + " " + str(_account.__class__.__name__) + ")"]
result_form.fields.append(FieldNoType(name=var_name, result_form.fields.append(FieldNoType(name=var_name,
label=var_label, label=var_label,
@@ -763,23 +765,65 @@ class JCLCommandManager(CommandManager):
command_node, lang_class): command_node, lang_class):
self.__logger.debug("Executing command 'announce' step 2") self.__logger.debug("Executing command 'announce' step 2")
announcement = session_context["announcement"][0] announcement = session_context["announcement"][0]
accounts = account.get_all_user_jids(\ users = account.get_all_users(\
filter=(Account.q._status != account.OFFLINE)) filter=AND(Account.q.userID == User.q.id,
Account.q._status != account.OFFLINE),
distinct=True)
result = [] result = []
for _account in accounts: for user in users:
result.append(Message(from_jid=self.component.jid, result.append(Message(from_jid=self.component.jid,
to_jid=_account.user_jid, to_jid=user.jid,
body=announcement)) body=announcement))
command_node.setProp("status", STATUS_COMPLETED) command_node.setProp("status", STATUS_COMPLETED)
return (None, result) return (None, result)
def execute_set_motd(self, info_query): def execute_set_motd_1(self, info_query, session_context,
command_node, lang_class):
self.add_actions(command_node, [ACTION_NEXT])
result_form = Form(xmlnode_or_type="result",
title="TODO",
instructions="TODO")
result_form.add_field(field_type="hidden",
name="FORM_TYPE",
value="http://jabber.org/protocol/admin")
result_form.add_field(name="motd",
field_type="text-multi",
label="TODO",
required=True)
result_form.as_xml(command_node)
return (result_form, [])
def execute_set_motd_2(self, info_query, session_context,
command_node, lang_class):
self.__logger.debug("Executing command 'set motd' step 2")
motd = session_context["motd"][0]
self.component.set_motd(motd)
users = account.get_all_users(\
filter=AND(Account.q.userID == User.q.id,
Account.q._status != account.OFFLINE),
distinct=True)
result = []
for user in users:
for _account in user.accounts:
if _account.status == account.OFFLINE:
user.has_received_motd = False
else:
user.has_received_motd = True
if user.has_received_motd:
result.extend(self.component.get_motd(user.jid))
command_node.setProp("status", STATUS_COMPLETED)
return (None, result)
def execute_edit_motd_1(self, info_query, session_context,
command_node, lang_class):
return [] return []
def execute_edit_motd(self, info_query): def execute_edit_motd_2(self, info_query, session_context,
command_node, lang_class):
return [] return []
def execute_delete_motd(self, info_query): def execute_delete_motd_1(self, info_query, session_context,
command_node, lang_class):
return [] return []
def execute_set_welcome(self, info_query): def execute_set_welcome(self, info_query):

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

@@ -61,7 +61,7 @@ from jcl.jabber.register import RootSetRegisterHandler, \
AccountSetRegisterHandler, AccountTypeSetRegisterHandler AccountSetRegisterHandler, AccountTypeSetRegisterHandler
import jcl.model as model import jcl.model as model
from jcl.model import account from jcl.model import account
from jcl.model.account import Account from jcl.model.account import Account, User
from jcl.lang import Lang from jcl.lang import Lang
VERSION = "0.1" VERSION = "0.1"
@@ -85,6 +85,8 @@ class JCLComponent(Component, object):
secret, secret,
server, server,
port, port,
config,
config_file="jmc.conf",
disco_category="headline", disco_category="headline",
disco_type="x-unknown", disco_type="x-unknown",
lang=Lang()): lang=Lang()):
@@ -98,6 +100,8 @@ class JCLComponent(Component, object):
# default values # default values
self.name = lang.get_default_lang_class().component_name self.name = lang.get_default_lang_class().component_name
self.spool_dir = "." self.spool_dir = "."
self.config = config
self.config_file = config_file
self.version = VERSION self.version = VERSION
self.time_unit = 60 self.time_unit = 60
self.queue = Queue(100) self.queue = Queue(100)
@@ -553,6 +557,28 @@ class JCLComponent(Component, object):
% (exception, "".join(traceback.format_exception % (exception, "".join(traceback.format_exception
(type, value, stack, 5)))) (type, value, stack, 5))))
def get_motd(self, to_jid):
if self.config is not None \
and self.config.has_option("component", "motd"):
motd = self.config.get("component", "motd")
return [Message(from_jid=self.jid,
to_jid=to_jid,
body=motd)]
else:
return []
def set_motd(self, motd):
if not self.config.has_section("component"):
self.config.add_section("component")
self.config.set("component", "motd", motd)
configFile = open(self.config_file, "w")
self.config.write(configFile)
def del_motd(self):
if self.config.has_section("component") \
and self.config.has_option("component", "motd"):
self.config.remove_option("component", "motd")
########################################################################### ###########################################################################
# Virtual methods # Virtual methods
########################################################################### ###########################################################################
@@ -693,7 +719,7 @@ class AccountManager(object):
new_account, first_account, from_jid=None): new_account, first_account, from_jid=None):
"""Populate given account""" """Populate given account"""
if from_jid is None: if from_jid is None:
from_jid = _account.user_jid from_jid = _account.user.jid
field = None field = None
result = [] result = []
model.db_connect() model.db_connect()
@@ -764,7 +790,7 @@ class AccountManager(object):
bare_from_jid = unicode(from_jid.bare()) bare_from_jid = unicode(from_jid.bare())
first_account = (account.get_accounts_count(bare_from_jid) == 0) first_account = (account.get_accounts_count(bare_from_jid) == 0)
model.db_connect() model.db_connect()
_account = account_class(user_jid=unicode(bare_from_jid), _account = account_class(user=User(jid=unicode(bare_from_jid)),
name=account_name, name=account_name,
jid=self.get_account_jid(account_name)) jid=self.get_account_jid(account_name))
model.db_disconnect() model.db_disconnect()
@@ -810,19 +836,15 @@ class AccountManager(object):
def send_presence_all(self, presence): def send_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"""
current_user_jid = None
result = [] result = []
model.db_connect() model.db_connect()
# Explicit reference to account table (clauseTables) to use # Explicit reference to account table (clauseTables) to use
# "user_jid" column with Account subclasses # "user_jid" column with Account subclasses
for _account in \ for user in account.get_all_users():
Account.select(clauseTables=["account"], result.extend(self.send_presence(self.component.jid,
orderBy=["user_jid", "name"]): user.jid,
if current_user_jid != _account.user_jid: presence))
current_user_jid = _account.user_jid for _account in account.get_all_accounts():
result.extend(self.send_presence(self.component.jid,
_account.user_jid,
presence))
result.extend(getattr(self, "send_presence_" + result.extend(getattr(self, "send_presence_" +
presence)(_account)) presence)(_account))
model.db_disconnect() model.db_disconnect()
@@ -932,7 +954,7 @@ class AccountManager(object):
Return register form for an existing account (update) Return register form for an existing account (update)
""" """
reg_form = self.generate_registration_form(lang_class, _account.__class__, reg_form = self.generate_registration_form(lang_class, _account.__class__,
_account.user_jid) _account.user.jid)
reg_form["name"].value = _account.name reg_form["name"].value = _account.name
reg_form["name"].type = "hidden" reg_form["name"].type = "hidden"
for field in reg_form.fields: for field in reg_form.fields:
@@ -947,7 +969,7 @@ class AccountManager(object):
def send_presence_probe(self, _account): def send_presence_probe(self, _account):
"""Send presence probe to account's user""" """Send presence probe to account's user"""
return [Presence(from_jid=_account.jid, return [Presence(from_jid=_account.jid,
to_jid=_account.user_jid, to_jid=_account.user.jid,
stanza_type="probe")] stanza_type="probe")]
def send_presence_unavailable(self, _account): def send_presence_unavailable(self, _account):
@@ -955,7 +977,7 @@ class AccountManager(object):
model.db_connect() model.db_connect()
_account.status = account.OFFLINE _account.status = account.OFFLINE
result = [Presence(from_jid=_account.jid, result = [Presence(from_jid=_account.jid,
to_jid=_account.user_jid, to_jid=_account.user.jid,
stanza_type="unavailable")] stanza_type="unavailable")]
model.db_disconnect() model.db_disconnect()
return result return result
@@ -991,7 +1013,7 @@ class AccountManager(object):
else: else:
_account.status = show _account.status = show
result.append(Presence(from_jid=_account.jid, result.append(Presence(from_jid=_account.jid,
to_jid=_account.user_jid, to_jid=_account.user.jid,
status=_account.status_msg, status=_account.status_msg,
show=show, show=show,
stanza_type="available")) stanza_type="available"))
@@ -1025,7 +1047,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=_account.user.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 % \
@@ -1053,7 +1075,7 @@ class AccountManager(object):
if _account.in_error == False: if _account.in_error == False:
_account.in_error = True _account.in_error = True
result.append(Message(from_jid=_account.jid, result.append(Message(from_jid=_account.jid,
to_jid=_account.user_jid, to_jid=_account.user.jid,
stanza_type="error", stanza_type="error",
subject=_account.default_lang_class.error_subject, subject=_account.default_lang_class.error_subject,
body=_account.default_lang_class.error_body \ body=_account.default_lang_class.error_body \

12
src/jcl/jabber/feeder.py
View File

@@ -32,6 +32,7 @@ from jcl.jabber import Handler
from jcl.jabber.component import JCLComponent from jcl.jabber.component import JCLComponent
from jcl.lang import Lang from jcl.lang import Lang
import jcl.model as model import jcl.model as model
from jcl.model import account
from jcl.model.account import Account from jcl.model.account import Account
from pyxmpp.message import Message from pyxmpp.message import Message
@@ -49,12 +50,16 @@ class FeederComponent(JCLComponent):
secret, secret,
server, server,
port, port,
config,
config_file,
lang = Lang()): lang = Lang()):
JCLComponent.__init__(self, JCLComponent.__init__(self,
jid, jid,
secret, secret,
server, server,
port, port,
config,
config_file,
lang=lang) lang=lang)
# Define default feeder and sender, can be override # Define default feeder and sender, can be override
self.handler = FeederHandler(Feeder(self), Sender(self)) self.handler = FeederHandler(Feeder(self), Sender(self))
@@ -99,7 +104,7 @@ class MessageSender(Sender):
"""Create message to send""" """Create message to send"""
subject, body = data subject, body = data
return Message(from_jid=to_account.jid, return Message(from_jid=to_account.jid,
to_jid=to_account.user_jid, to_jid=to_account.user.jid,
subject=subject, subject=subject,
body=body) body=body)
@@ -117,7 +122,7 @@ class HeadlineSender(MessageSender):
"""Create headline to send""" """Create headline to send"""
subject, body = data subject, body = data
return Message(from_jid=to_account.jid, return Message(from_jid=to_account.jid,
to_jid=to_account.user_jid, to_jid=to_account.user.jid,
subject=subject, subject=subject,
stanza_type="headline", stanza_type="headline",
body=body) body=body)
@@ -138,8 +143,7 @@ class FeederHandler(Handler):
Filter account to be processed by the handler Filter account to be processed by the handler
return all accounts. return all accounts.
""" """
accounts = Account.select(clauseTables=["account"], accounts = account.get_all_accounts()
orderBy=["user_jid", "name"])
return accounts return accounts
def handle(self, stanza, lang_class, data): def handle(self, stanza, lang_class, data):

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

@@ -24,6 +24,7 @@
from pyxmpp.presence import Presence from pyxmpp.presence import Presence
from jcl.jabber import Handler from jcl.jabber import Handler
from jcl.model import account
import jcl.jabber as jabber import jcl.jabber as jabber
class DefaultPresenceHandler(Handler): class DefaultPresenceHandler(Handler):
@@ -104,11 +105,17 @@ class RootPresenceHandler(AccountPresenceHandler):
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):
return self.component.account_manager.send_root_presence(stanza.get_from(), from_jid = stanza.get_from()
"available", result = self.component.account_manager.send_root_presence(from_jid,
stanza.get_show(), "available",
str(nb_accounts) + stanza.get_show(),
lang_class.message_status) str(nb_accounts) +
lang_class.message_status)
user = account.get_user(unicode(from_jid.bare()))
if not user.has_received_motd:
user.has_received_motd = True
result.extend(self.component.get_motd(from_jid))
return result
class AccountPresenceUnavailableHandler(AccountPresenceHandler): class AccountPresenceUnavailableHandler(AccountPresenceHandler):

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

@@ -21,6 +21,9 @@
## ##
import unittest import unittest
import os
import tempfile
from ConfigParser import ConfigParser
from pyxmpp.presence import Presence from pyxmpp.presence import Presence
from pyxmpp.jabber.dataforms import Form from pyxmpp.jabber.dataforms import Form
@@ -33,7 +36,7 @@ import jcl.jabber.command as command
from jcl.jabber.command import FieldNoType, JCLCommandManager from jcl.jabber.command import FieldNoType, JCLCommandManager
import jcl.model as model import jcl.model as model
import jcl.model.account as account import jcl.model.account as account
from jcl.model.account import Account, LegacyJID from jcl.model.account import Account, LegacyJID, User
from jcl.model.tests.account import ExampleAccount, Example2Account from jcl.model.tests.account import ExampleAccount, Example2Account
from jcl.tests import JCLTestCase from jcl.tests import JCLTestCase
@@ -58,14 +61,26 @@ class CommandManager_TestCase(unittest.TestCase):
class JCLCommandManager_TestCase(JCLTestCase): class JCLCommandManager_TestCase(JCLTestCase):
def setUp(self): def setUp(self):
JCLTestCase.setUp(self, tables=[Account, ExampleAccount, JCLTestCase.setUp(self, tables=[Account, ExampleAccount,
Example2Account, LegacyJID]) Example2Account, LegacyJID,
User])
self.config_file = tempfile.mktemp(".conf", "jcltest", "/tmp")
print str(self.config_file)
self.config = ConfigParser()
self.config.read(self.config_file)
self.comp = JCLComponent("jcl.test.com", self.comp = JCLComponent("jcl.test.com",
"password", "password",
"localhost", "localhost",
"5347") "5347",
self.config,
self.config_file)
self.command_manager = JCLCommandManager(self.comp, self.command_manager = JCLCommandManager(self.comp,
self.comp.account_manager) self.comp.account_manager)
def tearDown(self):
JCLTestCase.tearDown(self)
if os.path.exists(self.config_file):
os.unlink(self.config_file)
def __check_actions(self, info_query, expected_actions=None, action_index=0): def __check_actions(self, info_query, expected_actions=None, action_index=0):
actions = info_query.xpath_eval("c:command/c:actions", actions = info_query.xpath_eval("c:command/c:actions",
{"c": "http://jabber.org/protocol/commands"}) {"c": "http://jabber.org/protocol/commands"})
@@ -115,22 +130,25 @@ class JCLCommandManager_TestCase(JCLTestCase):
self.comp.account_manager.account_classes = (ExampleAccount, self.comp.account_manager.account_classes = (ExampleAccount,
Example2Account) Example2Account)
model.db_connect() model.db_connect()
account11 = ExampleAccount(user_jid="test1@test.com", user1 = User(jid="test1@test.com")
account11 = ExampleAccount(user=user1,
name="account11", name="account11",
jid="account11@jcl.test.com") jid="account11@jcl.test.com")
account12 = Example2Account(user_jid="test1@test.com", account12 = Example2Account(user=user1,
name="account12", name="account12",
jid="account12@jcl.test.com") jid="account12@jcl.test.com")
account21 = ExampleAccount(user_jid="test2@test.com", user2 = User(jid="test2@test.com")
account21 = ExampleAccount(user=user2,
name="account21", name="account21",
jid="account21@jcl.test.com") jid="account21@jcl.test.com")
account22 = ExampleAccount(user_jid="test2@test.com", account22 = ExampleAccount(user=user2,
name="account11", name="account11",
jid="account11@jcl.test.com") jid="account11@jcl.test.com")
account31 = ExampleAccount(user_jid="test3@test.com", user3 = User(jid="test3@test.com")
account31 = ExampleAccount(user=user3,
name="account31", name="account31",
jid="account31@jcl.test.com") jid="account31@jcl.test.com")
account32 = Example2Account(user_jid="test3@test.com", account32 = Example2Account(user=user3,
name="account32", name="account32",
jid="account32@jcl.test.com") jid="account32@jcl.test.com")
model.db_disconnect() model.db_disconnect()
@@ -179,23 +197,26 @@ class JCLCommandManager_TestCase(JCLTestCase):
self.comp.account_manager.account_classes = (ExampleAccount, self.comp.account_manager.account_classes = (ExampleAccount,
Example2Account) Example2Account)
model.db_connect() model.db_connect()
account11 = ExampleAccount(user_jid="test1@test.com", user1 = User(jid="test1@test.com")
account11 = ExampleAccount(user=user1,
name="account11", name="account11",
jid="account11@jcl.test.com") jid="account11@jcl.test.com")
account12 = Example2Account(user_jid="test1@test.com", account12 = Example2Account(user=user1,
name="account12", name="account12",
jid="account12@jcl.test.com") jid="account12@jcl.test.com")
account21 = ExampleAccount(user_jid="test2@test.com", user2 = User(jid="test2@test.com")
account21 = ExampleAccount(user=user2,
name="account21", name="account21",
jid="account21@jcl.test.com") jid="account21@jcl.test.com")
account21.enabled = False account21.enabled = False
account22 = ExampleAccount(user_jid="test2@test.com", account22 = ExampleAccount(user=user2,
name="account11", name="account11",
jid="account11@jcl.test.com") jid="account11@jcl.test.com")
account31 = ExampleAccount(user_jid="test3@test.com", user3 = User(jid="test3@test.com")
account31 = ExampleAccount(user=user3,
name="account31", name="account31",
jid="account31@jcl.test.com") jid="account31@jcl.test.com")
account32 = Example2Account(user_jid="test3@test.com", account32 = Example2Account(user=user3,
name="account32", name="account32",
jid="account32@jcl.test.com") jid="account32@jcl.test.com")
model.db_disconnect() model.db_disconnect()
@@ -240,22 +261,25 @@ class JCLCommandManager_TestCase(JCLTestCase):
self.comp.account_manager.account_classes = (ExampleAccount, self.comp.account_manager.account_classes = (ExampleAccount,
Example2Account) Example2Account)
model.db_connect() model.db_connect()
account11 = ExampleAccount(user_jid="test1@test.com", user1 = User(jid="test1@test.com")
user2 = User(jid="test2@test.com")
user3 = User(jid="test3@test.com")
account11 = ExampleAccount(user=user1,
name="account11", name="account11",
jid="account11@jcl.test.com") jid="account11@jcl.test.com")
account12 = Example2Account(user_jid="test1@test.com", account12 = Example2Account(user=user1,
name="account12", name="account12",
jid="account12@jcl.test.com") jid="account12@jcl.test.com")
account21 = ExampleAccount(user_jid="test2@test.com", account21 = ExampleAccount(user=user2,
name="account21", name="account21",
jid="account21@jcl.test.com") jid="account21@jcl.test.com")
account22 = ExampleAccount(user_jid="test2@test.com", account22 = ExampleAccount(user=user2,
name="account11", name="account11",
jid="account11@jcl.test.com") jid="account11@jcl.test.com")
account31 = ExampleAccount(user_jid="test3@test.com", account31 = ExampleAccount(user=user3,
name="account31", name="account31",
jid="account31@jcl.test.com") jid="account31@jcl.test.com")
account32 = Example2Account(user_jid="test3@test.com", account32 = Example2Account(user=user3,
name="account32", name="account32",
jid="account32@jcl.test.com") jid="account32@jcl.test.com")
model.db_disconnect() model.db_disconnect()
@@ -411,7 +435,7 @@ class JCLCommandManager_TestCase(JCLTestCase):
_account = account.get_account("user2@test.com", _account = account.get_account("user2@test.com",
"account1") "account1")
self.assertNotEquals(_account, None) self.assertNotEquals(_account, None)
self.assertEquals(_account.user_jid, "user2@test.com") self.assertEquals(_account.user.jid, "user2@test.com")
self.assertEquals(_account.name, "account1") self.assertEquals(_account.name, "account1")
self.assertEquals(_account.jid, "account1@jcl.test.com") self.assertEquals(_account.jid, "account1@jcl.test.com")
model.db_disconnect() model.db_disconnect()
@@ -639,22 +663,25 @@ class JCLCommandManager_TestCase(JCLTestCase):
self.comp.account_manager.account_classes = (ExampleAccount, self.comp.account_manager.account_classes = (ExampleAccount,
Example2Account) Example2Account)
model.db_connect() model.db_connect()
account11 = ExampleAccount(user_jid="test1@test.com", user1 = User(jid="test1@test.com")
user2 = User(jid="test2@test.com")
user3 = User(jid="test3@test.com")
account11 = ExampleAccount(user=user1,
name="account11", name="account11",
jid="account11@jcl.test.com") jid="account11@jcl.test.com")
account12 = Example2Account(user_jid="test1@test.com", account12 = Example2Account(user=user1,
name="account12", name="account12",
jid="account12@jcl.test.com") jid="account12@jcl.test.com")
account21 = ExampleAccount(user_jid="test2@test.com", account21 = ExampleAccount(user=user2,
name="account21", name="account21",
jid="account21@jcl.test.com") jid="account21@jcl.test.com")
account22 = ExampleAccount(user_jid="test2@test.com", account22 = ExampleAccount(user=user2,
name="account11", name="account11",
jid="account11@jcl.test.com") jid="account11@jcl.test.com")
account31 = ExampleAccount(user_jid="test3@test.com", account31 = ExampleAccount(user=user3,
name="account31", name="account31",
jid="account31@jcl.test.com") jid="account31@jcl.test.com")
account32 = Example2Account(user_jid="test3@test.com", account32 = Example2Account(user=user3,
name="account32", name="account32",
jid="account32@jcl.test.com") jid="account32@jcl.test.com")
model.db_disconnect() model.db_disconnect()
@@ -780,27 +807,30 @@ class JCLCommandManager_TestCase(JCLTestCase):
self.comp.account_manager.account_classes = (ExampleAccount, self.comp.account_manager.account_classes = (ExampleAccount,
Example2Account) Example2Account)
model.db_connect() model.db_connect()
account11 = ExampleAccount(user_jid="test1@test.com", user1 = User(jid="test1@test.com")
user2 = User(jid="test2@test.com")
user3 = User(jid="test3@test.com")
account11 = ExampleAccount(user=user1,
name="account11", name="account11",
jid="account11@jcl.test.com") jid="account11@jcl.test.com")
account11.enabled = True account11.enabled = True
account12 = Example2Account(user_jid="test1@test.com", account12 = Example2Account(user=user1,
name="account12", name="account12",
jid="account12@jcl.test.com") jid="account12@jcl.test.com")
account12.enabled = False account12.enabled = False
account21 = ExampleAccount(user_jid="test2@test.com", account21 = ExampleAccount(user=user2,
name="account21", name="account21",
jid="account21@jcl.test.com") jid="account21@jcl.test.com")
account21.enabled = False account21.enabled = False
account22 = ExampleAccount(user_jid="test2@test.com", account22 = ExampleAccount(user=user2,
name="account11", name="account11",
jid="account11@jcl.test.com") jid="account11@jcl.test.com")
account22.enabled = True account22.enabled = True
account31 = ExampleAccount(user_jid="test3@test.com", account31 = ExampleAccount(user=user3,
name="account31", name="account31",
jid="account31@jcl.test.com") jid="account31@jcl.test.com")
account31.enabled = False account31.enabled = False
account32 = Example2Account(user_jid="test3@test.com", account32 = Example2Account(user=user3,
name="account32", name="account32",
jid="account32@jcl.test.com") jid="account32@jcl.test.com")
account32.enabled = False account32.enabled = False
@@ -885,27 +915,30 @@ class JCLCommandManager_TestCase(JCLTestCase):
self.comp.account_manager.account_classes = (ExampleAccount, self.comp.account_manager.account_classes = (ExampleAccount,
Example2Account) Example2Account)
model.db_connect() model.db_connect()
account11 = ExampleAccount(user_jid="test1@test.com", user1 = User(jid="test1@test.com")
user2 = User(jid="test2@test.com")
user3 = User(jid="test3@test.com")
account11 = ExampleAccount(user=user1,
name="account11", name="account11",
jid="account11@jcl.test.com") jid="account11@jcl.test.com")
account11.enabled = False account11.enabled = False
account12 = Example2Account(user_jid="test1@test.com", account12 = Example2Account(user=user1,
name="account12", name="account12",
jid="account12@jcl.test.com") jid="account12@jcl.test.com")
account12.enabled = True account12.enabled = True
account21 = ExampleAccount(user_jid="test2@test.com", account21 = ExampleAccount(user=user2,
name="account21", name="account21",
jid="account21@jcl.test.com") jid="account21@jcl.test.com")
account21.enabled = True account21.enabled = True
account22 = ExampleAccount(user_jid="test2@test.com", account22 = ExampleAccount(user=user2,
name="account11", name="account11",
jid="account11@jcl.test.com") jid="account11@jcl.test.com")
account22.enabled = False account22.enabled = False
account31 = ExampleAccount(user_jid="test3@test.com", account31 = ExampleAccount(user=user3,
name="account31", name="account31",
jid="account31@jcl.test.com") jid="account31@jcl.test.com")
account31.enabled = True account31.enabled = True
account32 = Example2Account(user_jid="test3@test.com", account32 = Example2Account(user=user3,
name="account32", name="account32",
jid="account32@jcl.test.com") jid="account32@jcl.test.com")
account32.enabled = True account32.enabled = True
@@ -990,24 +1023,27 @@ class JCLCommandManager_TestCase(JCLTestCase):
self.comp.account_manager.account_classes = (ExampleAccount, self.comp.account_manager.account_classes = (ExampleAccount,
Example2Account) Example2Account)
model.db_connect() model.db_connect()
account11 = ExampleAccount(user_jid="test1@test.com", user1 = User(jid="test1@test.com")
user2 = User(jid="test2@test.com")
user3 = User(jid="test3@test.com")
account11 = ExampleAccount(user=user1,
name="account11", name="account11",
jid="account11@jcl.test.com") jid="account11@jcl.test.com")
account11.status = account.ONLINE account11.status = account.ONLINE
account12 = Example2Account(user_jid="test1@test.com", account12 = Example2Account(user=user1,
name="account12", name="account12",
jid="account12@jcl.test.com") jid="account12@jcl.test.com")
account21 = ExampleAccount(user_jid="test2@test.com", account21 = ExampleAccount(user=user2,
name="account21", name="account21",
jid="account21@jcl.test.com") jid="account21@jcl.test.com")
account22 = ExampleAccount(user_jid="test2@test.com", account22 = ExampleAccount(user=user2,
name="account11", name="account11",
jid="account11@jcl.test.com") jid="account11@jcl.test.com")
account22.status = account.ONLINE account22.status = account.ONLINE
account31 = ExampleAccount(user_jid="test3@test.com", account31 = ExampleAccount(user=user3,
name="account31", name="account31",
jid="account31@jcl.test.com") jid="account31@jcl.test.com")
account32 = Example2Account(user_jid="test3@test.com", account32 = Example2Account(user=user3,
name="account32", name="account32",
jid="account32@jcl.test.com") jid="account32@jcl.test.com")
model.db_disconnect() model.db_disconnect()
@@ -1108,17 +1144,19 @@ class JCLCommandManager_TestCase(JCLTestCase):
self.comp.account_manager.account_classes = (ExampleAccount, self.comp.account_manager.account_classes = (ExampleAccount,
Example2Account) Example2Account)
model.db_connect() model.db_connect()
account11 = ExampleAccount(user_jid="test1@test.com", user1 = User(jid="test1@test.com")
user2 = User(jid="test2@test.com")
account11 = ExampleAccount(user=user1,
name="account11", name="account11",
jid="account11@jcl.test.com") jid="account11@jcl.test.com")
account11.password = "pass1" account11.password = "pass1"
account12 = Example2Account(user_jid="test1@test.com", account12 = Example2Account(user=user1,
name="account12", name="account12",
jid="account12@jcl.test.com") jid="account12@jcl.test.com")
account21 = ExampleAccount(user_jid="test2@test.com", account21 = ExampleAccount(user=user2,
name="account21", name="account21",
jid="account21@jcl.test.com") jid="account21@jcl.test.com")
account22 = ExampleAccount(user_jid="test2@test.com", account22 = ExampleAccount(user=user2,
name="account11", name="account11",
jid="account11@jcl.test.com") jid="account11@jcl.test.com")
model.db_disconnect() model.db_disconnect()
@@ -1218,17 +1256,19 @@ class JCLCommandManager_TestCase(JCLTestCase):
self.comp.account_manager.account_classes = (ExampleAccount, self.comp.account_manager.account_classes = (ExampleAccount,
Example2Account) Example2Account)
model.db_connect() model.db_connect()
account11 = ExampleAccount(user_jid="test1@test.com", user1 = User(jid="test1@test.com")
account11 = ExampleAccount(user=user1,
name="account11", name="account11",
jid="account11@jcl.test.com") jid="account11@jcl.test.com")
account11.password = "pass1" account11.password = "pass1"
account12 = Example2Account(user_jid="test1@test.com", account12 = Example2Account(user=user1,
name="account12", name="account12",
jid="account12@jcl.test.com") jid="account12@jcl.test.com")
account21 = ExampleAccount(user_jid="test2@test.com", user2 = User(jid="test2@test.com")
account21 = ExampleAccount(user=user2,
name="account21", name="account21",
jid="account21@jcl.test.com") jid="account21@jcl.test.com")
account22 = ExampleAccount(user_jid="test2@test.com", account22 = ExampleAccount(user=user2,
name="account11", name="account11",
jid="account11@jcl.test.com") jid="account11@jcl.test.com")
model.db_disconnect() model.db_disconnect()
@@ -1314,7 +1354,8 @@ class JCLCommandManager_TestCase(JCLTestCase):
self.comp.account_manager.account_classes = (ExampleAccount, self.comp.account_manager.account_classes = (ExampleAccount,
Example2Account) Example2Account)
model.db_connect() model.db_connect()
account11 = ExampleAccount(user_jid="test1@test.com", user1 = User(jid="test1@test.com")
account11 = ExampleAccount(user=user1,
name="account11", name="account11",
jid="account11@jcl.test.com") jid="account11@jcl.test.com")
ljid111 = LegacyJID(legacy_address="test111@test.com", ljid111 = LegacyJID(legacy_address="test111@test.com",
@@ -1323,13 +1364,14 @@ class JCLCommandManager_TestCase(JCLTestCase):
ljid112 = LegacyJID(legacy_address="test112@test.com", ljid112 = LegacyJID(legacy_address="test112@test.com",
jid="test112%test.com@test.com", jid="test112%test.com@test.com",
account=account11) account=account11)
account12 = Example2Account(user_jid="test1@test.com", account12 = Example2Account(user=user1,
name="account12", name="account12",
jid="account12@jcl.test.com") jid="account12@jcl.test.com")
ljid121 = LegacyJID(legacy_address="test121@test.com", ljid121 = LegacyJID(legacy_address="test121@test.com",
jid="test121%test.com@test.com", jid="test121%test.com@test.com",
account=account12) account=account12)
account21 = ExampleAccount(user_jid="test2@test.com", user2 = User(jid="test2@test.com")
account21 = ExampleAccount(user=user2,
name="account21", name="account21",
jid="account21@jcl.test.com") jid="account21@jcl.test.com")
ljid211 = LegacyJID(legacy_address="test211@test.com", ljid211 = LegacyJID(legacy_address="test211@test.com",
@@ -1338,7 +1380,7 @@ class JCLCommandManager_TestCase(JCLTestCase):
ljid212 = LegacyJID(legacy_address="test212@test.com", ljid212 = LegacyJID(legacy_address="test212@test.com",
jid="test212%test.com@test.com", jid="test212%test.com@test.com",
account=account21) account=account21)
account22 = ExampleAccount(user_jid="test2@test.com", account22 = ExampleAccount(user=user2,
name="account11", name="account11",
jid="account11@jcl.test.com") jid="account11@jcl.test.com")
ljid221 = LegacyJID(legacy_address="test221@test.com", ljid221 = LegacyJID(legacy_address="test221@test.com",
@@ -1413,17 +1455,19 @@ class JCLCommandManager_TestCase(JCLTestCase):
self.comp.account_manager.account_classes = (ExampleAccount, self.comp.account_manager.account_classes = (ExampleAccount,
Example2Account) Example2Account)
model.db_connect() model.db_connect()
account11 = ExampleAccount(user_jid="test1@test.com", user1 = User(jid="test1@test.com")
account11 = ExampleAccount(user=user1,
name="account11", name="account11",
jid="account11@jcl.test.com") jid="account11@jcl.test.com")
account11.status = account.ONLINE account11.status = account.ONLINE
account12 = Example2Account(user_jid="test1@test.com", account12 = Example2Account(user=user1,
name="account12", name="account12",
jid="account12@jcl.test.com") jid="account12@jcl.test.com")
account21 = ExampleAccount(user_jid="test2@test.com", user2 = User(jid="test2@test.com")
account21 = ExampleAccount(user=user2,
name="account21", name="account21",
jid="account21@jcl.test.com") jid="account21@jcl.test.com")
account22 = ExampleAccount(user_jid="test2@test.com", account22 = ExampleAccount(user=user2,
name="account11", name="account11",
jid="account11@jcl.test.com") jid="account11@jcl.test.com")
model.db_disconnect() model.db_disconnect()
@@ -1514,16 +1558,18 @@ class JCLCommandManager_TestCase(JCLTestCase):
self.comp.account_manager.account_classes = (ExampleAccount, self.comp.account_manager.account_classes = (ExampleAccount,
Example2Account) Example2Account)
model.db_connect() model.db_connect()
account11 = ExampleAccount(user_jid="test1@test.com", user1 = User(jid="test1@test.com")
account11 = ExampleAccount(user=user1,
name="account11", name="account11",
jid="account11@jcl.test.com") jid="account11@jcl.test.com")
account12 = Example2Account(user_jid="test1@test.com", account12 = Example2Account(user=user1,
name="account12", name="account12",
jid="account12@jcl.test.com") jid="account12@jcl.test.com")
account21 = ExampleAccount(user_jid="test2@test.com", user2 = User(jid="test2@test.com")
account21 = ExampleAccount(user=user2,
name="account21", name="account21",
jid="account21@jcl.test.com") jid="account21@jcl.test.com")
account22 = ExampleAccount(user_jid="test2@test.com", account22 = ExampleAccount(user=user2,
name="account11", name="account11",
jid="account11@jcl.test.com") jid="account11@jcl.test.com")
model.db_disconnect() model.db_disconnect()
@@ -1554,17 +1600,19 @@ class JCLCommandManager_TestCase(JCLTestCase):
self.comp.account_manager.account_classes = (ExampleAccount, self.comp.account_manager.account_classes = (ExampleAccount,
Example2Account) Example2Account)
model.db_connect() model.db_connect()
account11 = ExampleAccount(user_jid="test1@test.com", user1 = User(jid="test1@test.com")
account11 = ExampleAccount(user=user1,
name="account11", name="account11",
jid="account11@jcl.test.com") jid="account11@jcl.test.com")
account11.enabled = False account11.enabled = False
account12 = Example2Account(user_jid="test1@test.com", account12 = Example2Account(user=user1,
name="account12", name="account12",
jid="account12@jcl.test.com") jid="account12@jcl.test.com")
account21 = ExampleAccount(user_jid="test2@test.com", user2 = User(jid="test2@test.com")
account21 = ExampleAccount(user=user2,
name="account21", name="account21",
jid="account21@jcl.test.com") jid="account21@jcl.test.com")
account22 = ExampleAccount(user_jid="test2@test.com", account22 = ExampleAccount(user=user2,
name="account11", name="account11",
jid="account11@jcl.test.com") jid="account11@jcl.test.com")
account22.enabled = False account22.enabled = False
@@ -1596,18 +1644,20 @@ class JCLCommandManager_TestCase(JCLTestCase):
self.comp.account_manager.account_classes = (ExampleAccount, self.comp.account_manager.account_classes = (ExampleAccount,
Example2Account) Example2Account)
model.db_connect() model.db_connect()
account11 = ExampleAccount(user_jid="test1@test.com", user1 = User(jid="test1@test.com")
account11 = ExampleAccount(user=user1,
name="account11", name="account11",
jid="account11@jcl.test.com") jid="account11@jcl.test.com")
account11.status = account.ONLINE account11.status = account.ONLINE
account12 = Example2Account(user_jid="test1@test.com", account12 = Example2Account(user=user1,
name="account12", name="account12",
jid="account12@jcl.test.com") jid="account12@jcl.test.com")
account12.status = "away" account12.status = "away"
account21 = ExampleAccount(user_jid="test2@test.com", user2 = User(jid="test2@test.com")
account21 = ExampleAccount(user=user2,
name="account21", name="account21",
jid="account21@jcl.test.com") jid="account21@jcl.test.com")
account22 = ExampleAccount(user_jid="test2@test.com", account22 = ExampleAccount(user=user2,
name="account11", name="account11",
jid="account11@jcl.test.com") jid="account11@jcl.test.com")
account22.status = "chat" account22.status = "chat"
@@ -1639,16 +1689,18 @@ class JCLCommandManager_TestCase(JCLTestCase):
self.comp.account_manager.account_classes = (ExampleAccount, self.comp.account_manager.account_classes = (ExampleAccount,
Example2Account) Example2Account)
model.db_connect() model.db_connect()
account11 = ExampleAccount(user_jid="test1@test.com", user1 = User(jid="test1@test.com")
account11 = ExampleAccount(user=user1,
name="account11", name="account11",
jid="account11@jcl.test.com") jid="account11@jcl.test.com")
account12 = Example2Account(user_jid="test1@test.com", account12 = Example2Account(user=user1,
name="account12", name="account12",
jid="account12@jcl.test.com") jid="account12@jcl.test.com")
account21 = ExampleAccount(user_jid="test2@test.com", user2 = User(jid="test2@test.com")
account21 = ExampleAccount(user=user2,
name="account21", name="account21",
jid="account21@jcl.test.com") jid="account21@jcl.test.com")
account22 = ExampleAccount(user_jid="test2@test.com", account22 = ExampleAccount(user=user2,
name="account11", name="account11",
jid="account11@jcl.test.com") jid="account11@jcl.test.com")
model.db_disconnect() model.db_disconnect()
@@ -1689,14 +1741,16 @@ class JCLCommandManager_TestCase(JCLTestCase):
self.comp.account_manager.account_classes = (ExampleAccount, self.comp.account_manager.account_classes = (ExampleAccount,
Example2Account) Example2Account)
model.db_connect() model.db_connect()
user1 = User(jid="test1@test.com")
user2 = User(jid="test2@test.com")
for i in xrange(10): for i in xrange(10):
ExampleAccount(user_jid="test1@test.com", ExampleAccount(user=user1,
name="account11" + str(i), name="account11" + str(i),
jid="account11" + str(i) + "@jcl.test.com") jid="account11" + str(i) + "@jcl.test.com")
Example2Account(user_jid="test1@test.com", Example2Account(user=user1,
name="account12" + str(i), name="account12" + str(i),
jid="account12" + str(i) + "@jcl.test.com") jid="account12" + str(i) + "@jcl.test.com")
ExampleAccount(user_jid="test2@test.com", ExampleAccount(user=user2,
name="account2" + str(i), name="account2" + str(i),
jid="account2" + str(i) + "@jcl.test.com") jid="account2" + str(i) + "@jcl.test.com")
model.db_disconnect() model.db_disconnect()
@@ -1798,18 +1852,20 @@ class JCLCommandManager_TestCase(JCLTestCase):
self.comp.account_manager.account_classes = (ExampleAccount, self.comp.account_manager.account_classes = (ExampleAccount,
Example2Account) Example2Account)
model.db_connect() model.db_connect()
account11 = ExampleAccount(user_jid="test1@test.com", user1 = User(jid="test1@test.com")
account11 = ExampleAccount(user=user1,
name="account11", name="account11",
jid="account11@jcl.test.com") jid="account11@jcl.test.com")
account11.enabled = False account11.enabled = False
account12 = Example2Account(user_jid="test1@test.com", account12 = Example2Account(user=user1,
name="account12", name="account12",
jid="account12@jcl.test.com") jid="account12@jcl.test.com")
account12.enabled = False account12.enabled = False
account21 = ExampleAccount(user_jid="test2@test.com", user2 = User(jid="test2@test.com")
account21 = ExampleAccount(user=user2,
name="account21", name="account21",
jid="account21@jcl.test.com") jid="account21@jcl.test.com")
account22 = ExampleAccount(user_jid="test2@test.com", account22 = ExampleAccount(user=user2,
name="account11", name="account11",
jid="account11@jcl.test.com") jid="account11@jcl.test.com")
account22.enabled = False account22.enabled = False
@@ -1851,16 +1907,18 @@ class JCLCommandManager_TestCase(JCLTestCase):
self.comp.account_manager.account_classes = (ExampleAccount, self.comp.account_manager.account_classes = (ExampleAccount,
Example2Account) Example2Account)
model.db_connect() model.db_connect()
user1 = User(jid="test1@test.com")
user2 = User(jid="test2@test.com")
for i in xrange(20): for i in xrange(20):
_account = ExampleAccount(user_jid="test1@test.com", _account = ExampleAccount(user=user1,
name="account11" + str(i), name="account11" + str(i),
jid="account11" + str(i) jid="account11" + str(i)
+ "@jcl.test.com") + "@jcl.test.com")
_account.enabled = False _account.enabled = False
Example2Account(user_jid="test1@test.com", Example2Account(user=user1,
name="account12" + str(i), name="account12" + str(i),
jid="account12" + str(i) + "@jcl.test.com") jid="account12" + str(i) + "@jcl.test.com")
_account = ExampleAccount(user_jid="test2@test.com", _account = ExampleAccount(user=user2,
name="account2" + str(i), name="account2" + str(i),
jid="account2" + str(i) jid="account2" + str(i)
+ "@jcl.test.com") + "@jcl.test.com")
@@ -1965,18 +2023,20 @@ class JCLCommandManager_TestCase(JCLTestCase):
self.comp.account_manager.account_classes = (ExampleAccount, self.comp.account_manager.account_classes = (ExampleAccount,
Example2Account) Example2Account)
model.db_connect() model.db_connect()
account11 = ExampleAccount(user_jid="test1@test.com", user1 = User(jid="test1@test.com")
account11 = ExampleAccount(user=user1,
name="account11", name="account11",
jid="account11@jcl.test.com") jid="account11@jcl.test.com")
account11.status = account.ONLINE account11.status = account.ONLINE
account12 = Example2Account(user_jid="test1@test.com", account12 = Example2Account(user=user1,
name="account12", name="account12",
jid="account12@jcl.test.com") jid="account12@jcl.test.com")
account12.status = "away" account12.status = "away"
account21 = ExampleAccount(user_jid="test2@test.com", user2 = User(jid="test2@test.com")
account21 = ExampleAccount(user=user2,
name="account21", name="account21",
jid="account21@jcl.test.com") jid="account21@jcl.test.com")
account22 = ExampleAccount(user_jid="test2@test.com", account22 = ExampleAccount(user=user2,
name="account11", name="account11",
jid="account11@jcl.test.com") jid="account11@jcl.test.com")
account22.status = "xa" account22.status = "xa"
@@ -2018,16 +2078,18 @@ class JCLCommandManager_TestCase(JCLTestCase):
self.comp.account_manager.account_classes = (ExampleAccount, self.comp.account_manager.account_classes = (ExampleAccount,
Example2Account) Example2Account)
model.db_connect() model.db_connect()
user1 = User(jid="test1@test.com")
user2 = User(jid="test2@test.com")
for i in xrange(20): for i in xrange(20):
_account = ExampleAccount(user_jid="test1@test.com", _account = ExampleAccount(user=user1,
name="account11" + str(i), name="account11" + str(i),
jid="account11" + str(i) jid="account11" + str(i)
+ "@jcl.test.com") + "@jcl.test.com")
_account.status = account.ONLINE _account.status = account.ONLINE
Example2Account(user_jid="test1@test.com", Example2Account(user=user1,
name="account12" + str(i), name="account12" + str(i),
jid="account12" + str(i) + "@jcl.test.com") jid="account12" + str(i) + "@jcl.test.com")
_account = ExampleAccount(user_jid="test2@test.com", _account = ExampleAccount(user=user2,
name="account2" + str(i), name="account2" + str(i),
jid="account2" + str(i) jid="account2" + str(i)
+ "@jcl.test.com") + "@jcl.test.com")
@@ -2132,18 +2194,20 @@ class JCLCommandManager_TestCase(JCLTestCase):
self.comp.account_manager.account_classes = (ExampleAccount, self.comp.account_manager.account_classes = (ExampleAccount,
Example2Account) Example2Account)
model.db_connect() model.db_connect()
account11 = ExampleAccount(user_jid="test1@test.com", user1 = User(jid="test1@test.com")
account11 = ExampleAccount(user=user1,
name="account11", name="account11",
jid="account11@jcl.test.com") jid="account11@jcl.test.com")
account11.status = account.ONLINE account11.status = account.ONLINE
account12 = Example2Account(user_jid="test1@test.com", account12 = Example2Account(user=user1,
name="account12", name="account12",
jid="account12@jcl.test.com") jid="account12@jcl.test.com")
account12.status = "away" account12.status = "away"
account21 = ExampleAccount(user_jid="test2@test.com", user2 = User(jid="test2@test.com")
account21 = ExampleAccount(user=user2,
name="account21", name="account21",
jid="account21@jcl.test.com") jid="account21@jcl.test.com")
account22 = ExampleAccount(user_jid="test2@test.com", account22 = ExampleAccount(user=user2,
name="account11", name="account11",
jid="account11@jcl.test.com") jid="account11@jcl.test.com")
account22.status = "xa" account22.status = "xa"
@@ -2209,14 +2273,88 @@ class JCLCommandManager_TestCase(JCLTestCase):
self.assertEquals(result[2].get_to(), "test2@test.com") self.assertEquals(result[2].get_to(), "test2@test.com")
self.assertEquals(result[2].get_body(), "test announce") self.assertEquals(result[2].get_body(), "test announce")
# def test_execute_set_motd(self): def test_execute_set_motd(self):
# #TODO : implement command self.comp.account_manager.account_classes = (ExampleAccount,
# info_query = Iq(stanza_type="set", Example2Account)
# from_jid="user1@test.com", model.db_connect()
# to_jid="jcl.test.com") user1 = User(jid="test1@test.com")
# result = self.command_manager.execute_add_user(info_query) account11 = ExampleAccount(user=user1,
# self.assertNotEquals(result, None) name="account11",
# self.assertEquals(len(result), 1) jid="account11@jcl.test.com")
account11.status = account.ONLINE
account12 = Example2Account(user=user1,
name="account12",
jid="account12@jcl.test.com")
account12.status = "away"
user2 = User(jid="test2@test.com")
account21 = ExampleAccount(user=user2,
name="account21",
jid="account21@jcl.test.com")
account21.status = account.OFFLINE
account22 = ExampleAccount(user=user2,
name="account11",
jid="account11@jcl.test.com")
account22.status = account.OFFLINE
model.db_disconnect()
info_query = Iq(stanza_type="set",
from_jid="user1@test.com",
to_jid="jcl.test.com")
command_node = info_query.set_new_content(command.COMMAND_NS, "command")
command_node.setProp("node",
"http://jabber.org/protocol/admin#set-motd")
result = self.command_manager.apply_command_action(\
info_query,
"http://jabber.org/protocol/admin#set-motd",
"execute")
self.assertNotEquals(result, None)
self.assertEquals(len(result), 1)
xml_command = result[0].xpath_eval("c:command",
{"c": "http://jabber.org/protocol/commands"})[0]
self.assertEquals(xml_command.prop("status"), "executing")
self.assertNotEquals(xml_command.prop("sessionid"), None)
self.__check_actions(result[0], ["next"])
fields = result[0].xpath_eval("c:command/data:x/data:field",
{"c": "http://jabber.org/protocol/commands",
"data": "jabber:x:data"})
self.assertEquals(len(fields), 2)
self.assertEquals(fields[1].prop("var"), "motd")
self.assertEquals(fields[1].prop("type"), "text-multi")
self.assertEquals(fields[1].children.name, "required")
# Second step
info_query = Iq(stanza_type="set",
from_jid="user1@test.com",
to_jid="jcl.test.com")
command_node = info_query.set_new_content(command.COMMAND_NS, "command")
command_node.setProp("node",
"http://jabber.org/protocol/admin#set-motd")
session_id = xml_command.prop("sessionid")
command_node.setProp("sessionid", session_id)
command_node.setProp("action", "next")
submit_form = Form(xmlnode_or_type="submit")
submit_form.add_field(field_type="text-multi",
name="motd",
value=["Message Of The Day"])
submit_form.as_xml(command_node)
result = self.command_manager.apply_command_action(\
info_query,
"http://jabber.org/protocol/admin#set-motd",
"execute")
self.assertNotEquals(result, None)
self.assertEquals(len(result), 2)
xml_command = result[0].xpath_eval("c:command",
{"c": "http://jabber.org/protocol/commands"})[0]
self.assertEquals(xml_command.prop("status"), "completed")
self.assertEquals(xml_command.prop("sessionid"), session_id)
self.__check_actions(result[0])
context_session = self.command_manager.sessions[session_id][1]
self.assertEquals(context_session["motd"],
["Message Of The Day"])
self.assertTrue(account11.user.has_received_motd)
self.assertEquals(result[1].get_from(), "jcl.test.com")
self.assertEquals(result[1].get_to(), "test1@test.com")
self.assertEquals(result[1].get_body(), "Message Of The Day")
self.assertFalse(account21.user.has_received_motd)
# def test_execute_edit_motd(self): # def test_execute_edit_motd(self):
# #TODO : implement command # #TODO : implement command

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

File diff suppressed because it is too large Load Diff

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

@@ -30,7 +30,7 @@ from sqlobject import *
from jcl.jabber.component import JCLComponent from jcl.jabber.component import JCLComponent
from jcl.jabber.feeder import FeederComponent, Feeder, Sender, MessageSender, \ from jcl.jabber.feeder import FeederComponent, Feeder, Sender, MessageSender, \
HeadlineSender, FeederHandler HeadlineSender, FeederHandler
from jcl.model.account import Account, LegacyJID from jcl.model.account import Account, LegacyJID, User
import jcl.model as model import jcl.model as model
from jcl.model.tests.account import ExampleAccount, Example2Account from jcl.model.tests.account import ExampleAccount, Example2Account
@@ -52,11 +52,13 @@ class SenderMock(object):
class FeederComponent_TestCase(JCLComponent_TestCase): class FeederComponent_TestCase(JCLComponent_TestCase):
def setUp(self): def setUp(self):
JCLTestCase.setUp(self, tables=[Account, LegacyJID, ExampleAccount, JCLTestCase.setUp(self, tables=[Account, LegacyJID, ExampleAccount,
Example2Account]) Example2Account, User])
self.comp = FeederComponent("jcl.test.com", self.comp = FeederComponent("jcl.test.com",
"password", "password",
"localhost", "localhost",
"5347") "5347",
None,
None)
def test_run(self): def test_run(self):
self.comp.time_unit = 1 self.comp.time_unit = 1
@@ -84,20 +86,21 @@ class FeederComponent_TestCase(JCLComponent_TestCase):
class AccountFeeder(Feeder): class AccountFeeder(Feeder):
def feed(self, _account): def feed(self, _account):
return [("Simple Message for account " + _account.name, return [("Simple Message for account " + _account.name,
"user_jid: " + _account.user_jid), "user_jid: " + _account.user.jid),
("Simple Message for account " + _account.name, ("Simple Message for account " + _account.name,
"jid: " + _account.jid)] "jid: " + _account.jid)]
self.comp.stream = MockStream() self.comp.stream = MockStream()
self.comp.stream_class = MockStream self.comp.stream_class = MockStream
model.db_connect() model.db_connect()
account11 = Account(user_jid="user1@test.com", user1 = User(jid="user1@test.com")
account11 = Account(user=user1,
name="account11", name="account11",
jid="account11@jcl.test.com") jid="account11@jcl.test.com")
account12 = Account(user_jid="user1@test.com", account12 = Account(user=user1,
name="account12", name="account12",
jid="account12@jcl.test.com") jid="account12@jcl.test.com")
account2 = Account(user_jid="user2@test.com", account2 = Account(user=User(jid="user2@test.com"),
name="account2", name="account2",
jid="account2@jcl.test.com") jid="account2@jcl.test.com")
self.comp.handler.feeder = AccountFeeder(self.comp) self.comp.handler.feeder = AccountFeeder(self.comp)
@@ -106,44 +109,44 @@ class FeederComponent_TestCase(JCLComponent_TestCase):
messages_sent = self.comp.stream.sent messages_sent = self.comp.stream.sent
self.assertEquals(len(messages_sent), 6) self.assertEquals(len(messages_sent), 6)
self.assertEqual(messages_sent[0].get_from(), "account11@jcl.test.com") self.assertEquals(messages_sent[0].get_from(), "account11@jcl.test.com")
self.assertEqual(messages_sent[0].get_to(), "user1@test.com") self.assertEquals(messages_sent[0].get_to(), "user1@test.com")
self.assertEqual(messages_sent[0].get_subject(), self.assertEquals(messages_sent[0].get_subject(),
"Simple Message for account account11") "Simple Message for account account11")
self.assertEqual(messages_sent[0].get_body(), self.assertEquals(messages_sent[0].get_body(),
"user_jid: user1@test.com") "user_jid: user1@test.com")
self.assertEqual(messages_sent[1].get_from(), "account11@jcl.test.com") self.assertEquals(messages_sent[1].get_from(), "account11@jcl.test.com")
self.assertEqual(messages_sent[1].get_to(), "user1@test.com") self.assertEquals(messages_sent[1].get_to(), "user1@test.com")
self.assertEqual(messages_sent[1].get_subject(), self.assertEquals(messages_sent[1].get_subject(),
"Simple Message for account account11") "Simple Message for account account11")
self.assertEqual(messages_sent[1].get_body(), self.assertEquals(messages_sent[1].get_body(),
"jid: account11@jcl.test.com") "jid: account11@jcl.test.com")
self.assertEqual(messages_sent[2].get_from(), "account12@jcl.test.com") self.assertEquals(messages_sent[2].get_from(), "account12@jcl.test.com")
self.assertEqual(messages_sent[2].get_to(), "user1@test.com") self.assertEquals(messages_sent[2].get_to(), "user1@test.com")
self.assertEqual(messages_sent[2].get_subject(), self.assertEquals(messages_sent[2].get_subject(),
"Simple Message for account account12") "Simple Message for account account12")
self.assertEqual(messages_sent[2].get_body(), self.assertEquals(messages_sent[2].get_body(),
"user_jid: user1@test.com") "user_jid: user1@test.com")
self.assertEqual(messages_sent[3].get_from(), "account12@jcl.test.com") self.assertEquals(messages_sent[3].get_from(), "account12@jcl.test.com")
self.assertEqual(messages_sent[3].get_to(), "user1@test.com") self.assertEquals(messages_sent[3].get_to(), "user1@test.com")
self.assertEqual(messages_sent[3].get_subject(), self.assertEquals(messages_sent[3].get_subject(),
"Simple Message for account account12") "Simple Message for account account12")
self.assertEqual(messages_sent[3].get_body(), self.assertEquals(messages_sent[3].get_body(),
"jid: account12@jcl.test.com") "jid: account12@jcl.test.com")
self.assertEqual(messages_sent[4].get_from(), "account2@jcl.test.com") self.assertEquals(messages_sent[4].get_from(), "account2@jcl.test.com")
self.assertEqual(messages_sent[4].get_to(), "user2@test.com") self.assertEquals(messages_sent[4].get_to(), "user2@test.com")
self.assertEqual(messages_sent[4].get_subject(), self.assertEquals(messages_sent[4].get_subject(),
"Simple Message for account account2") "Simple Message for account account2")
self.assertEqual(messages_sent[4].get_body(), self.assertEquals(messages_sent[4].get_body(),
"user_jid: user2@test.com") "user_jid: user2@test.com")
self.assertEqual(messages_sent[5].get_from(), "account2@jcl.test.com") self.assertEquals(messages_sent[5].get_from(), "account2@jcl.test.com")
self.assertEqual(messages_sent[5].get_to(), "user2@test.com") self.assertEquals(messages_sent[5].get_to(), "user2@test.com")
self.assertEqual(messages_sent[5].get_subject(), self.assertEquals(messages_sent[5].get_subject(),
"Simple Message for account account2") "Simple Message for account account2")
self.assertEqual(messages_sent[5].get_body(), self.assertEquals(messages_sent[5].get_body(),
"jid: account2@jcl.test.com") "jid: account2@jcl.test.com")
class Feeder_TestCase(unittest.TestCase): class Feeder_TestCase(unittest.TestCase):
def test_feed_exist(self): def test_feed_exist(self):
@@ -157,11 +160,13 @@ class Sender_TestCase(unittest.TestCase):
class MessageSender_TestCase(JCLTestCase): class MessageSender_TestCase(JCLTestCase):
def setUp(self): def setUp(self):
JCLTestCase.setUp(self, tables=[Account]) JCLTestCase.setUp(self, tables=[Account, User])
self.comp = FeederComponent("jcl.test.com", self.comp = FeederComponent("jcl.test.com",
"password", "password",
"localhost", "localhost",
"5347") "5347",
None,
None)
self.sender = MessageSender(self.comp) self.sender = MessageSender(self.comp)
self.message_type = None self.message_type = None
@@ -169,14 +174,14 @@ class MessageSender_TestCase(JCLTestCase):
self.comp.stream = MockStream() self.comp.stream = MockStream()
self.comp.stream_class = MockStream self.comp.stream_class = MockStream
model.db_connect() model.db_connect()
account11 = Account(user_jid="user1@test.com", account11 = Account(user=User(jid="user1@test.com"),
name="account11", name="account11",
jid="account11@jcl.test.com") jid="account11@jcl.test.com")
self.sender.send(account11, ("subject", "Body message")) self.sender.send(account11, ("subject", "Body message"))
self.assertEquals(len(self.comp.stream.sent), 1) self.assertEquals(len(self.comp.stream.sent), 1)
message = self.comp.stream.sent[0] message = self.comp.stream.sent[0]
self.assertEquals(message.get_from(), account11.jid) self.assertEquals(message.get_from(), account11.jid)
self.assertEquals(message.get_to(), account11.user_jid) self.assertEquals(message.get_to(), account11.user.jid)
self.assertEquals(message.get_subject(), "subject") self.assertEquals(message.get_subject(), "subject")
self.assertEquals(message.get_body(), "Body message") self.assertEquals(message.get_body(), "Body message")
self.assertEquals(message.get_type(), self.message_type) self.assertEquals(message.get_type(), self.message_type)
@@ -190,30 +195,34 @@ class HeadlineSender_TestCase(MessageSender_TestCase):
class FeederHandler_TestCase(JCLTestCase): class FeederHandler_TestCase(JCLTestCase):
def setUp(self): def setUp(self):
JCLTestCase.setUp(self, tables=[Account, ExampleAccount]) JCLTestCase.setUp(self, tables=[Account, ExampleAccount, User])
self.handler = FeederHandler(FeederMock(), SenderMock()) self.handler = FeederHandler(FeederMock(), SenderMock())
def test_filter(self): def test_filter(self):
model.db_connect() model.db_connect()
account12 = ExampleAccount(user_jid="user2@test.com", account12 = ExampleAccount(user=User(jid="user2@test.com"),
name="account12", name="account12",
jid="account12@jcl.test.com") jid="account12@jcl.test.com")
account11 = ExampleAccount(user_jid="user1@test.com", account11 = ExampleAccount(user=User(jid="user1@test.com"),
name="account11", name="account11",
jid="account11@jcl.test.com") jid="account11@jcl.test.com")
accounts = self.handler.filter(None, None) accounts = self.handler.filter(None, None)
self.assertEquals(accounts.count(), 2) i = 0
# accounts must be ordered by user_jid for _account in accounts:
self.assertEquals(accounts[0].name, "account11") i += 1
self.assertEquals(accounts[1].name, "account12") if i == 1:
self.assertEquals(_account.name, "account12")
else:
self.assertEquals(_account.name, "account11")
self.assertEquals(i, 2)
model.db_disconnect() model.db_disconnect()
def test_handle(self): def test_handle(self):
model.db_connect() model.db_connect()
account11 = ExampleAccount(user_jid="user1@test.com", account11 = ExampleAccount(user=User(jid="user1@test.com"),
name="account11", name="account11",
jid="account11@jcl.test.com") jid="account11@jcl.test.com")
account12 = ExampleAccount(user_jid="user2@test.com", account12 = ExampleAccount(user=User(jid="user2@test.com"),
name="account12", name="account12",
jid="account12@jcl.test.com") jid="account12@jcl.test.com")
accounts = self.handler.handle(None, None, [account11, account12]) accounts = self.handler.handle(None, None, [account11, account12])
@@ -225,11 +234,11 @@ class FeederHandler_TestCase(JCLTestCase):
def test_handle_disabled_account(self): def test_handle_disabled_account(self):
model.db_connect() model.db_connect()
account11 = ExampleAccount(user_jid="user1@test.com", account11 = ExampleAccount(user=User(jid="user1@test.com"),
name="account11", name="account11",
jid="account11@jcl.test.com") jid="account11@jcl.test.com")
account11.enabled = False account11.enabled = False
account12 = ExampleAccount(user_jid="user2@test.com", account12 = ExampleAccount(user=User(jid="user2@test.com"),
name="account12", name="account12",
jid="account12@jcl.test.com") jid="account12@jcl.test.com")
accounts = self.handler.handle(None, None, [account11, account12]) accounts = self.handler.handle(None, None, [account11, account12])
@@ -239,14 +248,14 @@ class FeederHandler_TestCase(JCLTestCase):
model.db_disconnect() model.db_disconnect()
def suite(): def suite():
suite = unittest.TestSuite() test_suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(FeederComponent_TestCase, 'test')) test_suite.addTest(unittest.makeSuite(FeederComponent_TestCase, 'test'))
suite.addTest(unittest.makeSuite(Feeder_TestCase, 'test')) test_suite.addTest(unittest.makeSuite(Feeder_TestCase, 'test'))
suite.addTest(unittest.makeSuite(Sender_TestCase, 'test')) test_suite.addTest(unittest.makeSuite(Sender_TestCase, 'test'))
suite.addTest(unittest.makeSuite(MessageSender_TestCase, 'test')) test_suite.addTest(unittest.makeSuite(MessageSender_TestCase, 'test'))
suite.addTest(unittest.makeSuite(HeadlineSender_TestCase, 'test')) test_suite.addTest(unittest.makeSuite(HeadlineSender_TestCase, 'test'))
suite.addTest(unittest.makeSuite(FeederHandler_TestCase, 'test')) test_suite.addTest(unittest.makeSuite(FeederHandler_TestCase, 'test'))
return suite return test_suite
if __name__ == '__main__': if __name__ == '__main__':
unittest.main(defaultTest='suite') unittest.main(defaultTest='suite')

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

@@ -29,14 +29,14 @@ from jcl.jabber.component import JCLComponent
from jcl.jabber.message import PasswordMessageHandler from jcl.jabber.message import PasswordMessageHandler
import jcl.model.account as account import jcl.model.account as account
import jcl.model as model import jcl.model as model
from jcl.model.account import Account from jcl.model.account import Account, User
from jcl.model.tests.account import ExampleAccount from jcl.model.tests.account import ExampleAccount
from jcl.tests import JCLTestCase from jcl.tests import JCLTestCase
class PasswordMessageHandler_TestCase(JCLTestCase): class PasswordMessageHandler_TestCase(JCLTestCase):
def setUp(self): def setUp(self):
JCLTestCase.setUp(self, tables=[Account, ExampleAccount]) JCLTestCase.setUp(self, tables=[User, Account, ExampleAccount])
self.comp = JCLComponent("jcl.test.com", self.comp = JCLComponent("jcl.test.com",
"password", "password",
"localhost", "localhost",
@@ -46,11 +46,12 @@ class PasswordMessageHandler_TestCase(JCLTestCase):
def test_filter_waiting_password(self): def test_filter_waiting_password(self):
model.db_connect() model.db_connect()
account11 = ExampleAccount(user_jid="user1@test.com", user1 = User(jid="user1@test.com")
account11 = ExampleAccount(user=user1,
name="account11", name="account11",
jid="account11@jcl.test.com") jid="account11@jcl.test.com")
account11.waiting_password_reply = True account11.waiting_password_reply = True
account12 = ExampleAccount(user_jid="user1@test.com", 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",
@@ -63,11 +64,12 @@ class PasswordMessageHandler_TestCase(JCLTestCase):
def test_filter_not_waiting_password(self): def test_filter_not_waiting_password(self):
model.db_connect() model.db_connect()
account11 = ExampleAccount(user_jid="user1@test.com", user1 = User(jid="user1@test.com")
account11 = ExampleAccount(user=user1,
name="account11", name="account11",
jid="account11@jcl.test.com") jid="account11@jcl.test.com")
account11.waiting_password_reply = False account11.waiting_password_reply = False
account12 = ExampleAccount(user_jid="user1@test.com", 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",
@@ -80,11 +82,12 @@ class PasswordMessageHandler_TestCase(JCLTestCase):
def test_filter_not_good_message(self): def test_filter_not_good_message(self):
model.db_connect() model.db_connect()
account11 = ExampleAccount(user_jid="user1@test.com", user1 = User(jid="user1@test.com")
account11 = ExampleAccount(user=user1,
name="account11", name="account11",
jid="account11@jcl.test.com") jid="account11@jcl.test.com")
account11.waiting_password_reply = True account11.waiting_password_reply = True
account12 = ExampleAccount(user_jid="user1@test.com", 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",
@@ -97,10 +100,11 @@ class PasswordMessageHandler_TestCase(JCLTestCase):
def test_filter_not_password_account(self): def test_filter_not_password_account(self):
model.db_connect() model.db_connect()
account11 = Account(user_jid="user1@test.com", user1 = User(jid="user1@test.com")
account11 = Account(user=user1,
name="account11", name="account11",
jid="account11@jcl.test.com") jid="account11@jcl.test.com")
account12 = Account(user_jid="user1@test.com", account12 = Account(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",
@@ -113,10 +117,11 @@ class PasswordMessageHandler_TestCase(JCLTestCase):
def test_handle(self): def test_handle(self):
model.db_connect() model.db_connect()
account11 = ExampleAccount(user_jid="user1@test.com", user1 = User(jid="user1@test.com")
account11 = ExampleAccount(user=user1,
name="account11", name="account11",
jid="account11@jcl.test.com") jid="account11@jcl.test.com")
account12 = ExampleAccount(user_jid="user1@test.com", 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",
@@ -129,9 +134,9 @@ class PasswordMessageHandler_TestCase(JCLTestCase):
model.db_disconnect() model.db_disconnect()
def suite(): def suite():
suite = unittest.TestSuite() test_suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(PasswordMessageHandler_TestCase, 'test')) test_suite.addTest(unittest.makeSuite(PasswordMessageHandler_TestCase, 'test'))
return suite return test_suite
if __name__ == '__main__': if __name__ == '__main__':
unittest.main(defaultTest='suite') unittest.main(defaultTest='suite')

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

@@ -21,11 +21,21 @@
## ##
import unittest import unittest
import tempfile
import os
from ConfigParser import ConfigParser
from pyxmpp.presence import Presence from pyxmpp.presence import Presence
from pyxmpp.message import Message
from jcl.jabber.component import JCLComponent
from jcl.jabber.presence import DefaultSubscribeHandler, \ from jcl.jabber.presence import DefaultSubscribeHandler, \
DefaultUnsubscribeHandler, DefaultPresenceHandler DefaultUnsubscribeHandler, DefaultPresenceHandler, \
RootPresenceAvailableHandler
from jcl.model.account import User, LegacyJID, Account
from jcl.lang import Lang
from jcl.tests import JCLTestCase
class DefaultSubscribeHandler_TestCase(unittest.TestCase): class DefaultSubscribeHandler_TestCase(unittest.TestCase):
def setUp(self): def setUp(self):
@@ -87,12 +97,96 @@ class DefaultPresenceHandler_TestCase(unittest.TestCase):
self.assertEquals(result[0].get_from(), "user1%test.com@jcl.test.com") self.assertEquals(result[0].get_from(), "user1%test.com@jcl.test.com")
self.assertEquals(result[0].get_type(), "unavailable") self.assertEquals(result[0].get_type(), "unavailable")
class RootPresenceAvailableHandler_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 = RootPresenceAvailableHandler(self.comp)
def tearDown(self):
JCLTestCase.tearDown(self)
if os.path.exists(self.config_file):
os.unlink(self.config_file)
def test_get_root_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="available",
from_jid="user1@test.com",
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")
self.assertEquals(result[0].get_from(), "jcl.test.com")
self.assertTrue(isinstance(result[1], Message))
self.assertEquals(result[1].get_to(), "user1@test.com")
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
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",
to_jid="jcl.test.com")
self.assertTrue(user1.has_received_motd)
result = self.handler.get_root_presence(presence, Lang.en, 2)
self.assertTrue(user1.has_received_motd)
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(), "jcl.test.com")
def test_get_root_presence_no_motd(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",
to_jid="jcl.test.com")
self.assertFalse(user1.has_received_motd)
self.config.remove_option("component", "motd")
result = self.handler.get_root_presence(presence, Lang.en, 2)
self.assertTrue(user1.has_received_motd)
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(), "jcl.test.com")
def suite(): def suite():
suite = unittest.TestSuite() test_suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(DefaultSubscribeHandler_TestCase, 'test')) test_suite.addTest(unittest.makeSuite(DefaultSubscribeHandler_TestCase, 'test'))
suite.addTest(unittest.makeSuite(DefaultUnsubscribeHandler_TestCase, 'test')) test_suite.addTest(unittest.makeSuite(DefaultUnsubscribeHandler_TestCase, 'test'))
suite.addTest(unittest.makeSuite(DefaultPresenceHandler_TestCase, 'test')) test_suite.addTest(unittest.makeSuite(DefaultPresenceHandler_TestCase, 'test'))
return suite test_suite.addTest(unittest.makeSuite(RootPresenceAvailableHandler_TestCase, 'test'))
return test_suite
if __name__ == '__main__': if __name__ == '__main__':
unittest.main(defaultTest='suite') unittest.main(defaultTest='suite')

59
src/jcl/model/account.py
View File

@@ -59,11 +59,36 @@ def mandatory_field(field_name, field_value):
raise FieldError(field_name, "Field required") # TODO : add translated message raise FieldError(field_name, "Field required") # TODO : add translated message
return field_value return field_value
class User(InheritableSQLObject):
_connection = model.hub
jid = StringCol()
has_received_motd = BoolCol(default=False)
accounts = MultipleJoin("Account")
def get_user(bare_from_jid, user_class=User):
result = None
model.db_connect()
users = user_class.select(User.q.jid == bare_from_jid)
model.db_disconnect()
if users.count() > 0:
result = users[0]
return result
def get_all_users(user_class=User, limit=None, filter=None,
distinct=False):
model.db_connect()
users = user_class.select(clause=filter, limit=limit,
distinct=distinct)
for user in users:
yield user
model.db_disconnect()
class Account(InheritableSQLObject): class Account(InheritableSQLObject):
"""Base Account class""" """Base Account class"""
_cacheValue = False _cacheValue = False
_connection = model.hub _connection = model.hub
user_jid = StringCol()
name = StringCol() name = StringCol()
jid = StringCol() jid = StringCol()
_status = StringCol(default=OFFLINE, dbName="status") _status = StringCol(default=OFFLINE, dbName="status")
@@ -71,6 +96,7 @@ class Account(InheritableSQLObject):
legacy_jids = MultipleJoin('LegacyJID') legacy_jids = MultipleJoin('LegacyJID')
enabled = BoolCol(default=True) enabled = BoolCol(default=True)
lastlogin = DateTimeCol(default=datetime.datetime.today()) lastlogin = DateTimeCol(default=datetime.datetime.today())
user = ForeignKey("User")
## Use these attributs to support volatile password ## Use these attributs to support volatile password
## login = StringCol(default = "") ## login = StringCol(default = "")
@@ -148,8 +174,9 @@ def get_account(bare_user_jid, name, account_class=Account):
result = None result = None
model.db_connect() model.db_connect()
accounts = account_class.select(\ accounts = account_class.select(\
AND(account_class.q.name == name, AND(AND(Account.q.name == name,
account_class.q.user_jid == unicode(bare_user_jid))) Account.q.userID == User.q.id),
User.q.jid == unicode(bare_user_jid)))
if accounts.count() > 0: if accounts.count() > 0:
result = accounts[0] result = accounts[0]
model.db_disconnect() model.db_disconnect()
@@ -158,10 +185,12 @@ def get_account(bare_user_jid, name, account_class=Account):
def get_accounts(bare_user_jid, account_class=Account, filter=None): def get_accounts(bare_user_jid, account_class=Account, filter=None):
model.db_connect() model.db_connect()
if filter is not None: if filter is not None:
filter = AND(account_class.q.user_jid == unicode(bare_user_jid), filter = AND(AND(Account.q.userID == User.q.id,
User.q.jid == unicode(bare_user_jid)),
filter) filter)
else: else:
filter = account_class.q.user_jid == unicode(bare_user_jid) filter = AND(Account.q.userID == User.q.id,
User.q.jid == unicode(bare_user_jid))
accounts = account_class.select(filter) accounts = account_class.select(filter)
if accounts.count() == 0: if accounts.count() == 0:
model.db_disconnect() model.db_disconnect()
@@ -180,7 +209,8 @@ def get_all_accounts(account_class=Account, filter=None, limit=None):
def get_accounts_count(bare_user_jid, account_class=Account): def get_accounts_count(bare_user_jid, account_class=Account):
model.db_connect() model.db_connect()
accounts_count = account_class.select(\ accounts_count = account_class.select(\
account_class.q.user_jid == unicode(bare_user_jid)).count() AND(Account.q.userID == User.q.id,
User.q.jid == unicode(bare_user_jid))).count()
model.db_disconnect() model.db_disconnect()
return accounts_count return accounts_count
@@ -193,18 +223,6 @@ def get_all_accounts_count(account_class=Account, filter=None):
model.db_disconnect() model.db_disconnect()
return accounts_count return accounts_count
def get_all_user_jids(account_class=Account, limit=None, filter=None):
model.db_connect()
accounts = account_class.select(clause=filter, limit=limit,
orderBy=["user_jid"])
current_account = None
for _account in accounts:
if current_account is None \
or current_account.user_jid != _account.user_jid:
current_account = _account
yield _account
model.db_disconnect()
class PresenceAccount(Account): class PresenceAccount(Account):
DO_NOTHING = 0 DO_NOTHING = 0
DO_SOMETHING = 1 DO_SOMETHING = 1
@@ -333,8 +351,9 @@ class PresenceAccount(Account):
def get_legacy_jids(bare_to_jid): def get_legacy_jids(bare_to_jid):
model.db_connect() model.db_connect()
legacy_jids = LegacyJID.select(\ legacy_jids = LegacyJID.select(\
AND(LegacyJID.q.accountID == Account.q.id, AND(AND(LegacyJID.q.accountID == Account.q.id,
Account.q.user_jid == bare_to_jid)) Account.q.userID == User.q.id),
User.q.jid == bare_to_jid))
for legacy_jid in legacy_jids: for legacy_jid in legacy_jids:
yield legacy_jid yield legacy_jid
model.db_disconnect() model.db_disconnect()

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

@@ -28,7 +28,7 @@ from sqlobject import *
from jcl.error import FieldError from jcl.error import FieldError
import jcl.model as model import jcl.model as model
from jcl.model import account from jcl.model import account
from jcl.model.account import Account, PresenceAccount from jcl.model.account import Account, PresenceAccount, User
from jcl.tests import JCLTestCase from jcl.tests import JCLTestCase
@@ -118,7 +118,10 @@ class PresenceAccountExample(PresenceAccount):
lambda bare_from_jid: 43)] lambda bare_from_jid: 43)]
get_register_fields = classmethod(_get_register_fields) get_register_fields = classmethod(_get_register_fields)
class AccountModule_TestCase(unittest.TestCase): class AccountModule_TestCase(JCLTestCase):
def setUp(self):
JCLTestCase.setUp(self, tables=[User, Account, ExampleAccount])
def test_default_post_func(self): def test_default_post_func(self):
result = account.default_post_func("test", None, "user1@jcl.test.com") result = account.default_post_func("test", None, "user1@jcl.test.com")
self.assertEquals(result, "test") self.assertEquals(result, "test")
@@ -162,6 +165,58 @@ class AccountModule_TestCase(unittest.TestCase):
self.assertEquals(account.mandatory_field("test", "value"), self.assertEquals(account.mandatory_field("test", "value"),
"value") "value")
def test_get_accounts(self):
user1 = User(jid="user1@test.com")
Account(user=user1,
name="account11",
jid="accout11@jcl.test.com")
Account(user=user1,
name="account12",
jid="accout12@jcl.test.com")
Account(user=User(jid="test2@test.com"),
name="account11",
jid="accout11@jcl.test.com")
accounts = account.get_accounts("user1@test.com")
i = 0
for _account in accounts:
i += 1
self.assertEquals(_account.user.jid, "user1@test.com")
self.assertEquals(i, 2)
def test_get_accounts_type(self):
user1 = User(jid="user1@test.com")
Account(user=user1,
name="account11",
jid="accout11@jcl.test.com")
ExampleAccount(user=user1,
name="account12",
jid="accout12@jcl.test.com")
ExampleAccount(user=User(jid="test2@test.com"),
name="account11",
jid="accout11@jcl.test.com")
accounts = account.get_accounts("user1@test.com", ExampleAccount)
i = 0
for _account in accounts:
i += 1
self.assertEquals(_account.user.jid, "user1@test.com")
self.assertEquals(_account.name, "account12")
self.assertEquals(i, 1)
def test_get_account(self):
user1 = User(jid="user1@test.com")
ExampleAccount(user=user1,
name="account11",
jid="accout11@jcl.test.com")
ExampleAccount(user=user1,
name="account12",
jid="accout12@jcl.test.com")
ExampleAccount(user=User(jid="test2@test.com"),
name="account11",
jid="accout11@jcl.test.com")
_account = account.get_account("user1@test.com", "account11")
self.assertEquals(_account.user.jid, "user1@test.com")
self.assertEquals(_account.name, "account11")
class InheritableAccount_TestCase(JCLTestCase): class InheritableAccount_TestCase(JCLTestCase):
def test_get_register_fields(self): def test_get_register_fields(self):
@@ -187,12 +242,12 @@ class InheritableAccount_TestCase(JCLTestCase):
class Account_TestCase(InheritableAccount_TestCase): class Account_TestCase(InheritableAccount_TestCase):
def setUp(self): def setUp(self):
JCLTestCase.setUp(self, tables=[Account, ExampleAccount]) JCLTestCase.setUp(self, tables=[User, Account, ExampleAccount])
self.account_class = Account self.account_class = Account
def test_set_status(self): def test_set_status(self):
model.db_connect() model.db_connect()
account11 = Account(user_jid="test1@test.com", account11 = Account(user=User(jid="test1@test.com"),
name="account11", name="account11",
jid="account11@jcl.test.com") jid="account11@jcl.test.com")
account11.status = account.OFFLINE account11.status = account.OFFLINE
@@ -202,7 +257,7 @@ class Account_TestCase(InheritableAccount_TestCase):
def test_set_status_live_password(self): def test_set_status_live_password(self):
model.db_connect() model.db_connect()
account11 = ExampleAccount(user_jid="test1@test.com", account11 = ExampleAccount(user=User(jid="test1@test.com"),
name="account11", name="account11",
jid="account11@jcl.test.com", jid="account11@jcl.test.com",
login="mylogin", login="mylogin",
@@ -219,11 +274,11 @@ class Account_TestCase(InheritableAccount_TestCase):
class PresenceAccount_TestCase(InheritableAccount_TestCase): class PresenceAccount_TestCase(InheritableAccount_TestCase):
def setUp(self): def setUp(self):
JCLTestCase.setUp(self, tables=[Account, PresenceAccount, JCLTestCase.setUp(self, tables=[User, Account, PresenceAccount,
PresenceAccountExample]) PresenceAccountExample])
model.db_connect() model.db_connect()
self.account = PresenceAccountExample(\ self.account = PresenceAccountExample(\
user_jid="test1@test.com", user=User(jid="test1@test.com"),
name="account11", name="account11",
jid="account11@jcl.test.com") jid="account11@jcl.test.com")
model.db_disconnect() model.db_disconnect()

21
src/jcl/runner.py
View File

@@ -28,8 +28,9 @@ from getopt import gnu_getopt
from sqlobject import * from sqlobject import *
from jcl.lang import Lang
from jcl.jabber.component import JCLComponent
import jcl.model as model import jcl.model as model
from jcl.model import account
from jcl.model.account import Account, PresenceAccount from jcl.model.account import Account, PresenceAccount
class JCLRunner(object): class JCLRunner(object):
@@ -41,7 +42,7 @@ class JCLRunner(object):
""" """
self.component_name = component_name self.component_name = component_name
self.component_version = component_version self.component_version = component_version
self.config_file = None self.config_file = "jmc.conf"
self.server = "localhost" self.server = "localhost"
self.port = 5347 self.port = 5347
self.secret = "secret" self.secret = "secret"
@@ -107,12 +108,12 @@ class JCLRunner(object):
self.config_file = commandline_args["config_file"] self.config_file = commandline_args["config_file"]
elif commandline_args.has_key("c"): elif commandline_args.has_key("c"):
self.config_file = commandline_args["c"] self.config_file = commandline_args["c"]
if self.config_file is not None: self.config = ConfigParser()
self.config = ConfigParser() self.logger.debug("Loading config file " + self.config_file)
self.logger.debug("Loading config file " + self.config_file) read_file = self.config.read(self.config_file)
read_file = self.config.read(self.config_file) if read_file == []:
if read_file == []: self.logger.info("Creating empty config file " + self.config_file)
raise IOError(2, "No such file or directory", str(self.config_file)) else:
for opt in cleanopts: for opt in cleanopts:
if len(opt) > 1: if len(opt) > 1:
(section, set_func) = cleanopts[opt] (section, set_func) = cleanopts[opt]
@@ -205,7 +206,9 @@ class JCLRunner(object):
secret=self.secret, secret=self.secret,
server=self.server, server=self.server,
port=self.port, port=self.port,
lang=Lang(self.language)) lang=Lang(self.language),
config=self.config,
config_file=self.config_file)
component.run() component.run()
self._run(run_func) self._run(run_func)

16
src/jcl/tests/__init__.py
View File

@@ -21,10 +21,10 @@ class JCLTestCase(unittest.TestCase):
def setUp(self, tables=[]): def setUp(self, tables=[]):
self.tables = tables self.tables = tables
self.db_path = tempfile.mktemp("db", "jcltest", DB_DIR) self.db_path = tempfile.mktemp(".db", "jcltest", DB_DIR)
if os.path.exists(self.db_path): if os.path.exists(self.db_path):
os.unlink(self.db_path) os.unlink(self.db_path)
self.db_url = "sqlite://" + self.db_path self.db_url = "sqlite://" + self.db_path #+ "?debug=True"
jcl.model.db_connection_str = self.db_url jcl.model.db_connection_str = self.db_url
jcl.model.db_connect() jcl.model.db_connect()
for table in tables: for table in tables:
@@ -45,12 +45,12 @@ def suite():
from jcl.tests import lang, runner from jcl.tests import lang, runner
from jcl.jabber import tests as jabber from jcl.jabber import tests as jabber
from jcl.model import tests as model from jcl.model import tests as model
suite = unittest.TestSuite() test_suite = unittest.TestSuite()
suite.addTest(lang.suite()) test_suite.addTest(lang.suite())
suite.addTest(runner.suite()) test_suite.addTest(runner.suite())
suite.addTest(jabber.suite()) test_suite.addTest(jabber.suite())
suite.addTest(model.suite()) test_suite.addTest(model.suite())
return suite return test_suite
if __name__ == '__main__': if __name__ == '__main__':
unittest.main(defaultTest='suite') unittest.main(defaultTest='suite')

8
src/jcl/tests/runner.py
View File

@@ -48,7 +48,7 @@ class JCLRunner_TestCase(unittest.TestCase):
def test_configure_default(self): def test_configure_default(self):
self.runner.configure() self.runner.configure()
self.assertEquals(self.runner.config_file, None) self.assertEquals(self.runner.config_file, "jmc.conf")
self.assertEquals(self.runner.server, "localhost") self.assertEquals(self.runner.server, "localhost")
self.assertEquals(self.runner.port, 5347) self.assertEquals(self.runner.port, 5347)
self.assertEquals(self.runner.secret, "secret") self.assertEquals(self.runner.secret, "secret")
@@ -139,9 +139,9 @@ class JCLRunner_TestCase(unittest.TestCase):
self.assertNotEquals(self.runner._get_help(), None) self.assertNotEquals(self.runner._get_help(), None)
def suite(): def suite():
suite = unittest.TestSuite() test_suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(JCLRunner_TestCase, 'test')) test_suite.addTest(unittest.makeSuite(JCLRunner_TestCase, 'test'))
return suite return test_suite
if __name__ == '__main__': if __name__ == '__main__':
unittest.main(defaultTest='suite') unittest.main(defaultTest='suite')