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

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

@@ -25,6 +25,8 @@ import re
import datetime
import logging
from sqlobject.sqlbuilder import AND
from pyxmpp.jid import JID
from pyxmpp.jabber.disco import DiscoInfo, DiscoItems, DiscoItem, DiscoIdentity
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.model import account
from jcl.model.account import Account
from jcl.model.account import Account, User
COMMAND_NS = "http://jabber.org/protocol/commands"
@@ -364,7 +366,7 @@ class JCLCommandManager(CommandManager):
accounts = account.get_all_accounts(filter=filter, limit=limit)
accounts_labels = []
for _account in accounts:
accounts_labels += [_account.user_jid + " (" + _account.name
accounts_labels += [_account.user.jid + " (" + _account.name
+ " " + str(_account.__class__.__name__) + ")"]
result_form.fields.append(FieldNoType(name=var_name,
label=var_label,
@@ -763,23 +765,65 @@ class JCLCommandManager(CommandManager):
command_node, lang_class):
self.__logger.debug("Executing command 'announce' step 2")
announcement = session_context["announcement"][0]
accounts = account.get_all_user_jids(\
filter=(Account.q._status != account.OFFLINE))
users = account.get_all_users(\
filter=AND(Account.q.userID == User.q.id,
Account.q._status != account.OFFLINE),
distinct=True)
result = []
for _account in accounts:
for user in users:
result.append(Message(from_jid=self.component.jid,
to_jid=_account.user_jid,
to_jid=user.jid,
body=announcement))
command_node.setProp("status", STATUS_COMPLETED)
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 []
def execute_edit_motd(self, info_query):
def execute_edit_motd_2(self, info_query, session_context,
command_node, lang_class):
return []
def execute_delete_motd(self, info_query):
def execute_delete_motd_1(self, info_query, session_context,
command_node, lang_class):
return []
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
import jcl.model as model
from jcl.model import account
from jcl.model.account import Account
from jcl.model.account import Account, User
from jcl.lang import Lang
VERSION = "0.1"
@@ -85,6 +85,8 @@ class JCLComponent(Component, object):
secret,
server,
port,
config,
config_file="jmc.conf",
disco_category="headline",
disco_type="x-unknown",
lang=Lang()):
@@ -98,6 +100,8 @@ class JCLComponent(Component, object):
# default values
self.name = lang.get_default_lang_class().component_name
self.spool_dir = "."
self.config = config
self.config_file = config_file
self.version = VERSION
self.time_unit = 60
self.queue = Queue(100)
@@ -553,6 +557,28 @@ class JCLComponent(Component, object):
% (exception, "".join(traceback.format_exception
(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
###########################################################################
@@ -693,7 +719,7 @@ class AccountManager(object):
new_account, first_account, from_jid=None):
"""Populate given account"""
if from_jid is None:
from_jid = _account.user_jid
from_jid = _account.user.jid
field = None
result = []
model.db_connect()
@@ -764,7 +790,7 @@ class AccountManager(object):
bare_from_jid = unicode(from_jid.bare())
first_account = (account.get_accounts_count(bare_from_jid) == 0)
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,
jid=self.get_account_jid(account_name))
model.db_disconnect()
@@ -810,19 +836,15 @@ class AccountManager(object):
def send_presence_all(self, presence):
"""Send presence to all account. Optimized to use only one sql
request"""
current_user_jid = None
result = []
model.db_connect()
# Explicit reference to account table (clauseTables) to use
# "user_jid" column with Account subclasses
for _account in \
Account.select(clauseTables=["account"],
orderBy=["user_jid", "name"]):
if current_user_jid != _account.user_jid:
current_user_jid = _account.user_jid
result.extend(self.send_presence(self.component.jid,
_account.user_jid,
presence))
for user in account.get_all_users():
result.extend(self.send_presence(self.component.jid,
user.jid,
presence))
for _account in account.get_all_accounts():
result.extend(getattr(self, "send_presence_" +
presence)(_account))
model.db_disconnect()
@@ -932,7 +954,7 @@ class AccountManager(object):
Return register form for an existing account (update)
"""
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"].type = "hidden"
for field in reg_form.fields:
@@ -947,7 +969,7 @@ class AccountManager(object):
def send_presence_probe(self, _account):
"""Send presence probe to account's user"""
return [Presence(from_jid=_account.jid,
to_jid=_account.user_jid,
to_jid=_account.user.jid,
stanza_type="probe")]
def send_presence_unavailable(self, _account):
@@ -955,7 +977,7 @@ class AccountManager(object):
model.db_connect()
_account.status = account.OFFLINE
result = [Presence(from_jid=_account.jid,
to_jid=_account.user_jid,
to_jid=_account.user.jid,
stanza_type="unavailable")]
model.db_disconnect()
return result
@@ -991,7 +1013,7 @@ class AccountManager(object):
else:
_account.status = show
result.append(Presence(from_jid=_account.jid,
to_jid=_account.user_jid,
to_jid=_account.user.jid,
status=_account.status_msg,
show=show,
stanza_type="available"))
@@ -1025,7 +1047,7 @@ class AccountManager(object):
and _account.status != account.OFFLINE:
_account.waiting_password_reply = True
result.append(Message(from_jid=_account.jid,
to_jid=_account.user_jid,
to_jid=_account.user.jid,
subject=u"[PASSWORD] " + \
lang_class.ask_password_subject,
body=lang_class.ask_password_body % \
@@ -1053,7 +1075,7 @@ class AccountManager(object):
if _account.in_error == False:
_account.in_error = True
result.append(Message(from_jid=_account.jid,
to_jid=_account.user_jid,
to_jid=_account.user.jid,
stanza_type="error",
subject=_account.default_lang_class.error_subject,
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.lang import Lang
import jcl.model as model
from jcl.model import account
from jcl.model.account import Account
from pyxmpp.message import Message
@@ -49,12 +50,16 @@ class FeederComponent(JCLComponent):
secret,
server,
port,
config,
config_file,
lang = Lang()):
JCLComponent.__init__(self,
jid,
secret,
server,
port,
config,
config_file,
lang=lang)
# Define default feeder and sender, can be override
self.handler = FeederHandler(Feeder(self), Sender(self))
@@ -99,7 +104,7 @@ class MessageSender(Sender):
"""Create message to send"""
subject, body = data
return Message(from_jid=to_account.jid,
to_jid=to_account.user_jid,
to_jid=to_account.user.jid,
subject=subject,
body=body)
@@ -117,7 +122,7 @@ class HeadlineSender(MessageSender):
"""Create headline to send"""
subject, body = data
return Message(from_jid=to_account.jid,
to_jid=to_account.user_jid,
to_jid=to_account.user.jid,
subject=subject,
stanza_type="headline",
body=body)
@@ -138,8 +143,7 @@ class FeederHandler(Handler):
Filter account to be processed by the handler
return all accounts.
"""
accounts = Account.select(clauseTables=["account"],
orderBy=["user_jid", "name"])
accounts = account.get_all_accounts()
return accounts
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 jcl.jabber import Handler
from jcl.model import account
import jcl.jabber as jabber
class DefaultPresenceHandler(Handler):
@@ -104,11 +105,17 @@ class RootPresenceHandler(AccountPresenceHandler):
class RootPresenceAvailableHandler(RootPresenceHandler, AccountPresenceAvailableHandler):
def get_root_presence(self, stanza, lang_class, nb_accounts):
return self.component.account_manager.send_root_presence(stanza.get_from(),
"available",
stanza.get_show(),
str(nb_accounts) +
lang_class.message_status)
from_jid = stanza.get_from()
result = self.component.account_manager.send_root_presence(from_jid,
"available",
stanza.get_show(),
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):

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

@@ -21,6 +21,9 @@
##
import unittest
import os
import tempfile
from ConfigParser import ConfigParser
from pyxmpp.presence import Presence
from pyxmpp.jabber.dataforms import Form
@@ -33,7 +36,7 @@ import jcl.jabber.command as command
from jcl.jabber.command import FieldNoType, JCLCommandManager
import jcl.model as model
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.tests import JCLTestCase
@@ -58,14 +61,26 @@ class CommandManager_TestCase(unittest.TestCase):
class JCLCommandManager_TestCase(JCLTestCase):
def setUp(self):
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",
"password",
"localhost",
"5347")
"5347",
self.config,
self.config_file)
self.command_manager = JCLCommandManager(self.comp,
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):
actions = info_query.xpath_eval("c:command/c:actions",
{"c": "http://jabber.org/protocol/commands"})
@@ -115,22 +130,25 @@ class JCLCommandManager_TestCase(JCLTestCase):
self.comp.account_manager.account_classes = (ExampleAccount,
Example2Account)
model.db_connect()
account11 = ExampleAccount(user_jid="test1@test.com",
user1 = User(jid="test1@test.com")
account11 = ExampleAccount(user=user1,
name="account11",
jid="account11@jcl.test.com")
account12 = Example2Account(user_jid="test1@test.com",
account12 = Example2Account(user=user1,
name="account12",
jid="account12@jcl.test.com")
account21 = ExampleAccount(user_jid="test2@test.com",
user2 = User(jid="test2@test.com")
account21 = ExampleAccount(user=user2,
name="account21",
jid="account21@jcl.test.com")
account22 = ExampleAccount(user_jid="test2@test.com",
account22 = ExampleAccount(user=user2,
name="account11",
jid="account11@jcl.test.com")
account31 = ExampleAccount(user_jid="test3@test.com",
user3 = User(jid="test3@test.com")
account31 = ExampleAccount(user=user3,
name="account31",
jid="account31@jcl.test.com")
account32 = Example2Account(user_jid="test3@test.com",
account32 = Example2Account(user=user3,
name="account32",
jid="account32@jcl.test.com")
model.db_disconnect()
@@ -179,23 +197,26 @@ class JCLCommandManager_TestCase(JCLTestCase):
self.comp.account_manager.account_classes = (ExampleAccount,
Example2Account)
model.db_connect()
account11 = ExampleAccount(user_jid="test1@test.com",
user1 = User(jid="test1@test.com")
account11 = ExampleAccount(user=user1,
name="account11",
jid="account11@jcl.test.com")
account12 = Example2Account(user_jid="test1@test.com",
account12 = Example2Account(user=user1,
name="account12",
jid="account12@jcl.test.com")
account21 = ExampleAccount(user_jid="test2@test.com",
user2 = User(jid="test2@test.com")
account21 = ExampleAccount(user=user2,
name="account21",
jid="account21@jcl.test.com")
account21.enabled = False
account22 = ExampleAccount(user_jid="test2@test.com",
account22 = ExampleAccount(user=user2,
name="account11",
jid="account11@jcl.test.com")
account31 = ExampleAccount(user_jid="test3@test.com",
user3 = User(jid="test3@test.com")
account31 = ExampleAccount(user=user3,
name="account31",
jid="account31@jcl.test.com")
account32 = Example2Account(user_jid="test3@test.com",
account32 = Example2Account(user=user3,
name="account32",
jid="account32@jcl.test.com")
model.db_disconnect()
@@ -240,22 +261,25 @@ class JCLCommandManager_TestCase(JCLTestCase):
self.comp.account_manager.account_classes = (ExampleAccount,
Example2Account)
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",
jid="account11@jcl.test.com")
account12 = Example2Account(user_jid="test1@test.com",
account12 = Example2Account(user=user1,
name="account12",
jid="account12@jcl.test.com")
account21 = ExampleAccount(user_jid="test2@test.com",
account21 = ExampleAccount(user=user2,
name="account21",
jid="account21@jcl.test.com")
account22 = ExampleAccount(user_jid="test2@test.com",
account22 = ExampleAccount(user=user2,
name="account11",
jid="account11@jcl.test.com")
account31 = ExampleAccount(user_jid="test3@test.com",
account31 = ExampleAccount(user=user3,
name="account31",
jid="account31@jcl.test.com")
account32 = Example2Account(user_jid="test3@test.com",
account32 = Example2Account(user=user3,
name="account32",
jid="account32@jcl.test.com")
model.db_disconnect()
@@ -411,7 +435,7 @@ class JCLCommandManager_TestCase(JCLTestCase):
_account = account.get_account("user2@test.com",
"account1")
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.jid, "account1@jcl.test.com")
model.db_disconnect()
@@ -639,22 +663,25 @@ class JCLCommandManager_TestCase(JCLTestCase):
self.comp.account_manager.account_classes = (ExampleAccount,
Example2Account)
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",
jid="account11@jcl.test.com")
account12 = Example2Account(user_jid="test1@test.com",
account12 = Example2Account(user=user1,
name="account12",
jid="account12@jcl.test.com")
account21 = ExampleAccount(user_jid="test2@test.com",
account21 = ExampleAccount(user=user2,
name="account21",
jid="account21@jcl.test.com")
account22 = ExampleAccount(user_jid="test2@test.com",
account22 = ExampleAccount(user=user2,
name="account11",
jid="account11@jcl.test.com")
account31 = ExampleAccount(user_jid="test3@test.com",
account31 = ExampleAccount(user=user3,
name="account31",
jid="account31@jcl.test.com")
account32 = Example2Account(user_jid="test3@test.com",
account32 = Example2Account(user=user3,
name="account32",
jid="account32@jcl.test.com")
model.db_disconnect()
@@ -780,27 +807,30 @@ class JCLCommandManager_TestCase(JCLTestCase):
self.comp.account_manager.account_classes = (ExampleAccount,
Example2Account)
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",
jid="account11@jcl.test.com")
account11.enabled = True
account12 = Example2Account(user_jid="test1@test.com",
account12 = Example2Account(user=user1,
name="account12",
jid="account12@jcl.test.com")
account12.enabled = False
account21 = ExampleAccount(user_jid="test2@test.com",
account21 = ExampleAccount(user=user2,
name="account21",
jid="account21@jcl.test.com")
account21.enabled = False
account22 = ExampleAccount(user_jid="test2@test.com",
account22 = ExampleAccount(user=user2,
name="account11",
jid="account11@jcl.test.com")
account22.enabled = True
account31 = ExampleAccount(user_jid="test3@test.com",
account31 = ExampleAccount(user=user3,
name="account31",
jid="account31@jcl.test.com")
account31.enabled = False
account32 = Example2Account(user_jid="test3@test.com",
account32 = Example2Account(user=user3,
name="account32",
jid="account32@jcl.test.com")
account32.enabled = False
@@ -885,27 +915,30 @@ class JCLCommandManager_TestCase(JCLTestCase):
self.comp.account_manager.account_classes = (ExampleAccount,
Example2Account)
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",
jid="account11@jcl.test.com")
account11.enabled = False
account12 = Example2Account(user_jid="test1@test.com",
account12 = Example2Account(user=user1,
name="account12",
jid="account12@jcl.test.com")
account12.enabled = True
account21 = ExampleAccount(user_jid="test2@test.com",
account21 = ExampleAccount(user=user2,
name="account21",
jid="account21@jcl.test.com")
account21.enabled = True
account22 = ExampleAccount(user_jid="test2@test.com",
account22 = ExampleAccount(user=user2,
name="account11",
jid="account11@jcl.test.com")
account22.enabled = False
account31 = ExampleAccount(user_jid="test3@test.com",
account31 = ExampleAccount(user=user3,
name="account31",
jid="account31@jcl.test.com")
account31.enabled = True
account32 = Example2Account(user_jid="test3@test.com",
account32 = Example2Account(user=user3,
name="account32",
jid="account32@jcl.test.com")
account32.enabled = True
@@ -990,24 +1023,27 @@ class JCLCommandManager_TestCase(JCLTestCase):
self.comp.account_manager.account_classes = (ExampleAccount,
Example2Account)
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",
jid="account11@jcl.test.com")
account11.status = account.ONLINE
account12 = Example2Account(user_jid="test1@test.com",
account12 = Example2Account(user=user1,
name="account12",
jid="account12@jcl.test.com")
account21 = ExampleAccount(user_jid="test2@test.com",
account21 = ExampleAccount(user=user2,
name="account21",
jid="account21@jcl.test.com")
account22 = ExampleAccount(user_jid="test2@test.com",
account22 = ExampleAccount(user=user2,
name="account11",
jid="account11@jcl.test.com")
account22.status = account.ONLINE
account31 = ExampleAccount(user_jid="test3@test.com",
account31 = ExampleAccount(user=user3,
name="account31",
jid="account31@jcl.test.com")
account32 = Example2Account(user_jid="test3@test.com",
account32 = Example2Account(user=user3,
name="account32",
jid="account32@jcl.test.com")
model.db_disconnect()
@@ -1108,17 +1144,19 @@ class JCLCommandManager_TestCase(JCLTestCase):
self.comp.account_manager.account_classes = (ExampleAccount,
Example2Account)
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",
jid="account11@jcl.test.com")
account11.password = "pass1"
account12 = Example2Account(user_jid="test1@test.com",
account12 = Example2Account(user=user1,
name="account12",
jid="account12@jcl.test.com")
account21 = ExampleAccount(user_jid="test2@test.com",
account21 = ExampleAccount(user=user2,
name="account21",
jid="account21@jcl.test.com")
account22 = ExampleAccount(user_jid="test2@test.com",
account22 = ExampleAccount(user=user2,
name="account11",
jid="account11@jcl.test.com")
model.db_disconnect()
@@ -1218,17 +1256,19 @@ class JCLCommandManager_TestCase(JCLTestCase):
self.comp.account_manager.account_classes = (ExampleAccount,
Example2Account)
model.db_connect()
account11 = ExampleAccount(user_jid="test1@test.com",
user1 = User(jid="test1@test.com")
account11 = ExampleAccount(user=user1,
name="account11",
jid="account11@jcl.test.com")
account11.password = "pass1"
account12 = Example2Account(user_jid="test1@test.com",
account12 = Example2Account(user=user1,
name="account12",
jid="account12@jcl.test.com")
account21 = ExampleAccount(user_jid="test2@test.com",
user2 = User(jid="test2@test.com")
account21 = ExampleAccount(user=user2,
name="account21",
jid="account21@jcl.test.com")
account22 = ExampleAccount(user_jid="test2@test.com",
account22 = ExampleAccount(user=user2,
name="account11",
jid="account11@jcl.test.com")
model.db_disconnect()
@@ -1314,7 +1354,8 @@ class JCLCommandManager_TestCase(JCLTestCase):
self.comp.account_manager.account_classes = (ExampleAccount,
Example2Account)
model.db_connect()
account11 = ExampleAccount(user_jid="test1@test.com",
user1 = User(jid="test1@test.com")
account11 = ExampleAccount(user=user1,
name="account11",
jid="account11@jcl.test.com")
ljid111 = LegacyJID(legacy_address="test111@test.com",
@@ -1323,13 +1364,14 @@ class JCLCommandManager_TestCase(JCLTestCase):
ljid112 = LegacyJID(legacy_address="test112@test.com",
jid="test112%test.com@test.com",
account=account11)
account12 = Example2Account(user_jid="test1@test.com",
account12 = Example2Account(user=user1,
name="account12",
jid="account12@jcl.test.com")
ljid121 = LegacyJID(legacy_address="test121@test.com",
jid="test121%test.com@test.com",
account=account12)
account21 = ExampleAccount(user_jid="test2@test.com",
user2 = User(jid="test2@test.com")
account21 = ExampleAccount(user=user2,
name="account21",
jid="account21@jcl.test.com")
ljid211 = LegacyJID(legacy_address="test211@test.com",
@@ -1338,7 +1380,7 @@ class JCLCommandManager_TestCase(JCLTestCase):
ljid212 = LegacyJID(legacy_address="test212@test.com",
jid="test212%test.com@test.com",
account=account21)
account22 = ExampleAccount(user_jid="test2@test.com",
account22 = ExampleAccount(user=user2,
name="account11",
jid="account11@jcl.test.com")
ljid221 = LegacyJID(legacy_address="test221@test.com",
@@ -1413,17 +1455,19 @@ class JCLCommandManager_TestCase(JCLTestCase):
self.comp.account_manager.account_classes = (ExampleAccount,
Example2Account)
model.db_connect()
account11 = ExampleAccount(user_jid="test1@test.com",
user1 = User(jid="test1@test.com")
account11 = ExampleAccount(user=user1,
name="account11",
jid="account11@jcl.test.com")
account11.status = account.ONLINE
account12 = Example2Account(user_jid="test1@test.com",
account12 = Example2Account(user=user1,
name="account12",
jid="account12@jcl.test.com")
account21 = ExampleAccount(user_jid="test2@test.com",
user2 = User(jid="test2@test.com")
account21 = ExampleAccount(user=user2,
name="account21",
jid="account21@jcl.test.com")
account22 = ExampleAccount(user_jid="test2@test.com",
account22 = ExampleAccount(user=user2,
name="account11",
jid="account11@jcl.test.com")
model.db_disconnect()
@@ -1514,16 +1558,18 @@ class JCLCommandManager_TestCase(JCLTestCase):
self.comp.account_manager.account_classes = (ExampleAccount,
Example2Account)
model.db_connect()
account11 = ExampleAccount(user_jid="test1@test.com",
user1 = User(jid="test1@test.com")
account11 = ExampleAccount(user=user1,
name="account11",
jid="account11@jcl.test.com")
account12 = Example2Account(user_jid="test1@test.com",
account12 = Example2Account(user=user1,
name="account12",
jid="account12@jcl.test.com")
account21 = ExampleAccount(user_jid="test2@test.com",
user2 = User(jid="test2@test.com")
account21 = ExampleAccount(user=user2,
name="account21",
jid="account21@jcl.test.com")
account22 = ExampleAccount(user_jid="test2@test.com",
account22 = ExampleAccount(user=user2,
name="account11",
jid="account11@jcl.test.com")
model.db_disconnect()
@@ -1554,17 +1600,19 @@ class JCLCommandManager_TestCase(JCLTestCase):
self.comp.account_manager.account_classes = (ExampleAccount,
Example2Account)
model.db_connect()
account11 = ExampleAccount(user_jid="test1@test.com",
user1 = User(jid="test1@test.com")
account11 = ExampleAccount(user=user1,
name="account11",
jid="account11@jcl.test.com")
account11.enabled = False
account12 = Example2Account(user_jid="test1@test.com",
account12 = Example2Account(user=user1,
name="account12",
jid="account12@jcl.test.com")
account21 = ExampleAccount(user_jid="test2@test.com",
user2 = User(jid="test2@test.com")
account21 = ExampleAccount(user=user2,
name="account21",
jid="account21@jcl.test.com")
account22 = ExampleAccount(user_jid="test2@test.com",
account22 = ExampleAccount(user=user2,
name="account11",
jid="account11@jcl.test.com")
account22.enabled = False
@@ -1596,18 +1644,20 @@ class JCLCommandManager_TestCase(JCLTestCase):
self.comp.account_manager.account_classes = (ExampleAccount,
Example2Account)
model.db_connect()
account11 = ExampleAccount(user_jid="test1@test.com",
user1 = User(jid="test1@test.com")
account11 = ExampleAccount(user=user1,
name="account11",
jid="account11@jcl.test.com")
account11.status = account.ONLINE
account12 = Example2Account(user_jid="test1@test.com",
account12 = Example2Account(user=user1,
name="account12",
jid="account12@jcl.test.com")
account12.status = "away"
account21 = ExampleAccount(user_jid="test2@test.com",
user2 = User(jid="test2@test.com")
account21 = ExampleAccount(user=user2,
name="account21",
jid="account21@jcl.test.com")
account22 = ExampleAccount(user_jid="test2@test.com",
account22 = ExampleAccount(user=user2,
name="account11",
jid="account11@jcl.test.com")
account22.status = "chat"
@@ -1639,16 +1689,18 @@ class JCLCommandManager_TestCase(JCLTestCase):
self.comp.account_manager.account_classes = (ExampleAccount,
Example2Account)
model.db_connect()
account11 = ExampleAccount(user_jid="test1@test.com",
user1 = User(jid="test1@test.com")
account11 = ExampleAccount(user=user1,
name="account11",
jid="account11@jcl.test.com")
account12 = Example2Account(user_jid="test1@test.com",
account12 = Example2Account(user=user1,
name="account12",
jid="account12@jcl.test.com")
account21 = ExampleAccount(user_jid="test2@test.com",
user2 = User(jid="test2@test.com")
account21 = ExampleAccount(user=user2,
name="account21",
jid="account21@jcl.test.com")
account22 = ExampleAccount(user_jid="test2@test.com",
account22 = ExampleAccount(user=user2,
name="account11",
jid="account11@jcl.test.com")
model.db_disconnect()
@@ -1689,14 +1741,16 @@ class JCLCommandManager_TestCase(JCLTestCase):
self.comp.account_manager.account_classes = (ExampleAccount,
Example2Account)
model.db_connect()
user1 = User(jid="test1@test.com")
user2 = User(jid="test2@test.com")
for i in xrange(10):
ExampleAccount(user_jid="test1@test.com",
ExampleAccount(user=user1,
name="account11" + str(i),
jid="account11" + str(i) + "@jcl.test.com")
Example2Account(user_jid="test1@test.com",
Example2Account(user=user1,
name="account12" + str(i),
jid="account12" + str(i) + "@jcl.test.com")
ExampleAccount(user_jid="test2@test.com",
ExampleAccount(user=user2,
name="account2" + str(i),
jid="account2" + str(i) + "@jcl.test.com")
model.db_disconnect()
@@ -1798,18 +1852,20 @@ class JCLCommandManager_TestCase(JCLTestCase):
self.comp.account_manager.account_classes = (ExampleAccount,
Example2Account)
model.db_connect()
account11 = ExampleAccount(user_jid="test1@test.com",
user1 = User(jid="test1@test.com")
account11 = ExampleAccount(user=user1,
name="account11",
jid="account11@jcl.test.com")
account11.enabled = False
account12 = Example2Account(user_jid="test1@test.com",
account12 = Example2Account(user=user1,
name="account12",
jid="account12@jcl.test.com")
account12.enabled = False
account21 = ExampleAccount(user_jid="test2@test.com",
user2 = User(jid="test2@test.com")
account21 = ExampleAccount(user=user2,
name="account21",
jid="account21@jcl.test.com")
account22 = ExampleAccount(user_jid="test2@test.com",
account22 = ExampleAccount(user=user2,
name="account11",
jid="account11@jcl.test.com")
account22.enabled = False
@@ -1851,16 +1907,18 @@ class JCLCommandManager_TestCase(JCLTestCase):
self.comp.account_manager.account_classes = (ExampleAccount,
Example2Account)
model.db_connect()
user1 = User(jid="test1@test.com")
user2 = User(jid="test2@test.com")
for i in xrange(20):
_account = ExampleAccount(user_jid="test1@test.com",
_account = ExampleAccount(user=user1,
name="account11" + str(i),
jid="account11" + str(i)
+ "@jcl.test.com")
_account.enabled = False
Example2Account(user_jid="test1@test.com",
Example2Account(user=user1,
name="account12" + str(i),
jid="account12" + str(i) + "@jcl.test.com")
_account = ExampleAccount(user_jid="test2@test.com",
_account = ExampleAccount(user=user2,
name="account2" + str(i),
jid="account2" + str(i)
+ "@jcl.test.com")
@@ -1965,18 +2023,20 @@ class JCLCommandManager_TestCase(JCLTestCase):
self.comp.account_manager.account_classes = (ExampleAccount,
Example2Account)
model.db_connect()
account11 = ExampleAccount(user_jid="test1@test.com",
user1 = User(jid="test1@test.com")
account11 = ExampleAccount(user=user1,
name="account11",
jid="account11@jcl.test.com")
account11.status = account.ONLINE
account12 = Example2Account(user_jid="test1@test.com",
account12 = Example2Account(user=user1,
name="account12",
jid="account12@jcl.test.com")
account12.status = "away"
account21 = ExampleAccount(user_jid="test2@test.com",
user2 = User(jid="test2@test.com")
account21 = ExampleAccount(user=user2,
name="account21",
jid="account21@jcl.test.com")
account22 = ExampleAccount(user_jid="test2@test.com",
account22 = ExampleAccount(user=user2,
name="account11",
jid="account11@jcl.test.com")
account22.status = "xa"
@@ -2018,16 +2078,18 @@ class JCLCommandManager_TestCase(JCLTestCase):
self.comp.account_manager.account_classes = (ExampleAccount,
Example2Account)
model.db_connect()
user1 = User(jid="test1@test.com")
user2 = User(jid="test2@test.com")
for i in xrange(20):
_account = ExampleAccount(user_jid="test1@test.com",
_account = ExampleAccount(user=user1,
name="account11" + str(i),
jid="account11" + str(i)
+ "@jcl.test.com")
_account.status = account.ONLINE
Example2Account(user_jid="test1@test.com",
Example2Account(user=user1,
name="account12" + str(i),
jid="account12" + str(i) + "@jcl.test.com")
_account = ExampleAccount(user_jid="test2@test.com",
_account = ExampleAccount(user=user2,
name="account2" + str(i),
jid="account2" + str(i)
+ "@jcl.test.com")
@@ -2132,18 +2194,20 @@ class JCLCommandManager_TestCase(JCLTestCase):
self.comp.account_manager.account_classes = (ExampleAccount,
Example2Account)
model.db_connect()
account11 = ExampleAccount(user_jid="test1@test.com",
user1 = User(jid="test1@test.com")
account11 = ExampleAccount(user=user1,
name="account11",
jid="account11@jcl.test.com")
account11.status = account.ONLINE
account12 = Example2Account(user_jid="test1@test.com",
account12 = Example2Account(user=user1,
name="account12",
jid="account12@jcl.test.com")
account12.status = "away"
account21 = ExampleAccount(user_jid="test2@test.com",
user2 = User(jid="test2@test.com")
account21 = ExampleAccount(user=user2,
name="account21",
jid="account21@jcl.test.com")
account22 = ExampleAccount(user_jid="test2@test.com",
account22 = ExampleAccount(user=user2,
name="account11",
jid="account11@jcl.test.com")
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_body(), "test announce")
# def test_execute_set_motd(self):
# #TODO : implement command
# info_query = Iq(stanza_type="set",
# from_jid="user1@test.com",
# to_jid="jcl.test.com")
# result = self.command_manager.execute_add_user(info_query)
# self.assertNotEquals(result, None)
# self.assertEquals(len(result), 1)
def test_execute_set_motd(self):
self.comp.account_manager.account_classes = (ExampleAccount,
Example2Account)
model.db_connect()
user1 = User(jid="test1@test.com")
account11 = ExampleAccount(user=user1,
name="account11",
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):
# #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.feeder import FeederComponent, Feeder, Sender, MessageSender, \
HeadlineSender, FeederHandler
from jcl.model.account import Account, LegacyJID
from jcl.model.account import Account, LegacyJID, User
import jcl.model as model
from jcl.model.tests.account import ExampleAccount, Example2Account
@@ -52,11 +52,13 @@ class SenderMock(object):
class FeederComponent_TestCase(JCLComponent_TestCase):
def setUp(self):
JCLTestCase.setUp(self, tables=[Account, LegacyJID, ExampleAccount,
Example2Account])
Example2Account, User])
self.comp = FeederComponent("jcl.test.com",
"password",
"localhost",
"5347")
"5347",
None,
None)
def test_run(self):
self.comp.time_unit = 1
@@ -84,20 +86,21 @@ class FeederComponent_TestCase(JCLComponent_TestCase):
class AccountFeeder(Feeder):
def feed(self, _account):
return [("Simple Message for account " + _account.name,
"user_jid: " + _account.user_jid),
"user_jid: " + _account.user.jid),
("Simple Message for account " + _account.name,
"jid: " + _account.jid)]
self.comp.stream = MockStream()
self.comp.stream_class = MockStream
model.db_connect()
account11 = Account(user_jid="user1@test.com",
user1 = User(jid="user1@test.com")
account11 = Account(user=user1,
name="account11",
jid="account11@jcl.test.com")
account12 = Account(user_jid="user1@test.com",
account12 = Account(user=user1,
name="account12",
jid="account12@jcl.test.com")
account2 = Account(user_jid="user2@test.com",
account2 = Account(user=User(jid="user2@test.com"),
name="account2",
jid="account2@jcl.test.com")
self.comp.handler.feeder = AccountFeeder(self.comp)
@@ -106,44 +109,44 @@ class FeederComponent_TestCase(JCLComponent_TestCase):
messages_sent = self.comp.stream.sent
self.assertEquals(len(messages_sent), 6)
self.assertEqual(messages_sent[0].get_from(), "account11@jcl.test.com")
self.assertEqual(messages_sent[0].get_to(), "user1@test.com")
self.assertEqual(messages_sent[0].get_subject(),
"Simple Message for account account11")
self.assertEqual(messages_sent[0].get_body(),
"user_jid: user1@test.com")
self.assertEqual(messages_sent[1].get_from(), "account11@jcl.test.com")
self.assertEqual(messages_sent[1].get_to(), "user1@test.com")
self.assertEqual(messages_sent[1].get_subject(),
"Simple Message for account account11")
self.assertEqual(messages_sent[1].get_body(),
"jid: account11@jcl.test.com")
self.assertEquals(messages_sent[0].get_from(), "account11@jcl.test.com")
self.assertEquals(messages_sent[0].get_to(), "user1@test.com")
self.assertEquals(messages_sent[0].get_subject(),
"Simple Message for account account11")
self.assertEquals(messages_sent[0].get_body(),
"user_jid: user1@test.com")
self.assertEquals(messages_sent[1].get_from(), "account11@jcl.test.com")
self.assertEquals(messages_sent[1].get_to(), "user1@test.com")
self.assertEquals(messages_sent[1].get_subject(),
"Simple Message for account account11")
self.assertEquals(messages_sent[1].get_body(),
"jid: account11@jcl.test.com")
self.assertEqual(messages_sent[2].get_from(), "account12@jcl.test.com")
self.assertEqual(messages_sent[2].get_to(), "user1@test.com")
self.assertEqual(messages_sent[2].get_subject(),
"Simple Message for account account12")
self.assertEqual(messages_sent[2].get_body(),
"user_jid: user1@test.com")
self.assertEqual(messages_sent[3].get_from(), "account12@jcl.test.com")
self.assertEqual(messages_sent[3].get_to(), "user1@test.com")
self.assertEqual(messages_sent[3].get_subject(),
"Simple Message for account account12")
self.assertEqual(messages_sent[3].get_body(),
"jid: account12@jcl.test.com")
self.assertEquals(messages_sent[2].get_from(), "account12@jcl.test.com")
self.assertEquals(messages_sent[2].get_to(), "user1@test.com")
self.assertEquals(messages_sent[2].get_subject(),
"Simple Message for account account12")
self.assertEquals(messages_sent[2].get_body(),
"user_jid: user1@test.com")
self.assertEquals(messages_sent[3].get_from(), "account12@jcl.test.com")
self.assertEquals(messages_sent[3].get_to(), "user1@test.com")
self.assertEquals(messages_sent[3].get_subject(),
"Simple Message for account account12")
self.assertEquals(messages_sent[3].get_body(),
"jid: account12@jcl.test.com")
self.assertEqual(messages_sent[4].get_from(), "account2@jcl.test.com")
self.assertEqual(messages_sent[4].get_to(), "user2@test.com")
self.assertEqual(messages_sent[4].get_subject(),
"Simple Message for account account2")
self.assertEqual(messages_sent[4].get_body(),
"user_jid: user2@test.com")
self.assertEqual(messages_sent[5].get_from(), "account2@jcl.test.com")
self.assertEqual(messages_sent[5].get_to(), "user2@test.com")
self.assertEqual(messages_sent[5].get_subject(),
"Simple Message for account account2")
self.assertEqual(messages_sent[5].get_body(),
"jid: account2@jcl.test.com")
self.assertEquals(messages_sent[4].get_from(), "account2@jcl.test.com")
self.assertEquals(messages_sent[4].get_to(), "user2@test.com")
self.assertEquals(messages_sent[4].get_subject(),
"Simple Message for account account2")
self.assertEquals(messages_sent[4].get_body(),
"user_jid: user2@test.com")
self.assertEquals(messages_sent[5].get_from(), "account2@jcl.test.com")
self.assertEquals(messages_sent[5].get_to(), "user2@test.com")
self.assertEquals(messages_sent[5].get_subject(),
"Simple Message for account account2")
self.assertEquals(messages_sent[5].get_body(),
"jid: account2@jcl.test.com")
class Feeder_TestCase(unittest.TestCase):
def test_feed_exist(self):
@@ -157,11 +160,13 @@ class Sender_TestCase(unittest.TestCase):
class MessageSender_TestCase(JCLTestCase):
def setUp(self):
JCLTestCase.setUp(self, tables=[Account])
JCLTestCase.setUp(self, tables=[Account, User])
self.comp = FeederComponent("jcl.test.com",
"password",
"localhost",
"5347")
"5347",
None,
None)
self.sender = MessageSender(self.comp)
self.message_type = None
@@ -169,14 +174,14 @@ class MessageSender_TestCase(JCLTestCase):
self.comp.stream = MockStream()
self.comp.stream_class = MockStream
model.db_connect()
account11 = Account(user_jid="user1@test.com",
account11 = Account(user=User(jid="user1@test.com"),
name="account11",
jid="account11@jcl.test.com")
self.sender.send(account11, ("subject", "Body message"))
self.assertEquals(len(self.comp.stream.sent), 1)
message = self.comp.stream.sent[0]
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_body(), "Body message")
self.assertEquals(message.get_type(), self.message_type)
@@ -190,30 +195,34 @@ class HeadlineSender_TestCase(MessageSender_TestCase):
class FeederHandler_TestCase(JCLTestCase):
def setUp(self):
JCLTestCase.setUp(self, tables=[Account, ExampleAccount])
JCLTestCase.setUp(self, tables=[Account, ExampleAccount, User])
self.handler = FeederHandler(FeederMock(), SenderMock())
def test_filter(self):
model.db_connect()
account12 = ExampleAccount(user_jid="user2@test.com",
account12 = ExampleAccount(user=User(jid="user2@test.com"),
name="account12",
jid="account12@jcl.test.com")
account11 = ExampleAccount(user_jid="user1@test.com",
account11 = ExampleAccount(user=User(jid="user1@test.com"),
name="account11",
jid="account11@jcl.test.com")
accounts = self.handler.filter(None, None)
self.assertEquals(accounts.count(), 2)
# accounts must be ordered by user_jid
self.assertEquals(accounts[0].name, "account11")
self.assertEquals(accounts[1].name, "account12")
i = 0
for _account in accounts:
i += 1
if i == 1:
self.assertEquals(_account.name, "account12")
else:
self.assertEquals(_account.name, "account11")
self.assertEquals(i, 2)
model.db_disconnect()
def test_handle(self):
model.db_connect()
account11 = ExampleAccount(user_jid="user1@test.com",
account11 = ExampleAccount(user=User(jid="user1@test.com"),
name="account11",
jid="account11@jcl.test.com")
account12 = ExampleAccount(user_jid="user2@test.com",
account12 = ExampleAccount(user=User(jid="user2@test.com"),
name="account12",
jid="account12@jcl.test.com")
accounts = self.handler.handle(None, None, [account11, account12])
@@ -225,11 +234,11 @@ class FeederHandler_TestCase(JCLTestCase):
def test_handle_disabled_account(self):
model.db_connect()
account11 = ExampleAccount(user_jid="user1@test.com",
account11 = ExampleAccount(user=User(jid="user1@test.com"),
name="account11",
jid="account11@jcl.test.com")
account11.enabled = False
account12 = ExampleAccount(user_jid="user2@test.com",
account12 = ExampleAccount(user=User(jid="user2@test.com"),
name="account12",
jid="account12@jcl.test.com")
accounts = self.handler.handle(None, None, [account11, account12])
@@ -239,14 +248,14 @@ class FeederHandler_TestCase(JCLTestCase):
model.db_disconnect()
def suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(FeederComponent_TestCase, 'test'))
suite.addTest(unittest.makeSuite(Feeder_TestCase, 'test'))
suite.addTest(unittest.makeSuite(Sender_TestCase, 'test'))
suite.addTest(unittest.makeSuite(MessageSender_TestCase, 'test'))
suite.addTest(unittest.makeSuite(HeadlineSender_TestCase, 'test'))
suite.addTest(unittest.makeSuite(FeederHandler_TestCase, 'test'))
return suite
test_suite = unittest.TestSuite()
test_suite.addTest(unittest.makeSuite(FeederComponent_TestCase, 'test'))
test_suite.addTest(unittest.makeSuite(Feeder_TestCase, 'test'))
test_suite.addTest(unittest.makeSuite(Sender_TestCase, 'test'))
test_suite.addTest(unittest.makeSuite(MessageSender_TestCase, 'test'))
test_suite.addTest(unittest.makeSuite(HeadlineSender_TestCase, 'test'))
test_suite.addTest(unittest.makeSuite(FeederHandler_TestCase, 'test'))
return test_suite
if __name__ == '__main__':
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
import jcl.model.account as account
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.tests import JCLTestCase
class PasswordMessageHandler_TestCase(JCLTestCase):
def setUp(self):
JCLTestCase.setUp(self, tables=[Account, ExampleAccount])
JCLTestCase.setUp(self, tables=[User, Account, ExampleAccount])
self.comp = JCLComponent("jcl.test.com",
"password",
"localhost",
@@ -46,11 +46,12 @@ class PasswordMessageHandler_TestCase(JCLTestCase):
def test_filter_waiting_password(self):
model.db_connect()
account11 = ExampleAccount(user_jid="user1@test.com",
user1 = User(jid="user1@test.com")
account11 = ExampleAccount(user=user1,
name="account11",
jid="account11@jcl.test.com")
account11.waiting_password_reply = True
account12 = ExampleAccount(user_jid="user1@test.com",
account12 = ExampleAccount(user=user1,
name="account12",
jid="account12@jcl.test.com")
message = Message(from_jid="user1@test.com",
@@ -63,11 +64,12 @@ class PasswordMessageHandler_TestCase(JCLTestCase):
def test_filter_not_waiting_password(self):
model.db_connect()
account11 = ExampleAccount(user_jid="user1@test.com",
user1 = User(jid="user1@test.com")
account11 = ExampleAccount(user=user1,
name="account11",
jid="account11@jcl.test.com")
account11.waiting_password_reply = False
account12 = ExampleAccount(user_jid="user1@test.com",
account12 = ExampleAccount(user=user1,
name="account12",
jid="account12@jcl.test.com")
message = Message(from_jid="user1@test.com",
@@ -80,11 +82,12 @@ class PasswordMessageHandler_TestCase(JCLTestCase):
def test_filter_not_good_message(self):
model.db_connect()
account11 = ExampleAccount(user_jid="user1@test.com",
user1 = User(jid="user1@test.com")
account11 = ExampleAccount(user=user1,
name="account11",
jid="account11@jcl.test.com")
account11.waiting_password_reply = True
account12 = ExampleAccount(user_jid="user1@test.com",
account12 = ExampleAccount(user=user1,
name="account12",
jid="account12@jcl.test.com")
message = Message(from_jid="user1@test.com",
@@ -97,10 +100,11 @@ class PasswordMessageHandler_TestCase(JCLTestCase):
def test_filter_not_password_account(self):
model.db_connect()
account11 = Account(user_jid="user1@test.com",
user1 = User(jid="user1@test.com")
account11 = Account(user=user1,
name="account11",
jid="account11@jcl.test.com")
account12 = Account(user_jid="user1@test.com",
account12 = Account(user=user1,
name="account12",
jid="account12@jcl.test.com")
message = Message(from_jid="user1@test.com",
@@ -113,10 +117,11 @@ class PasswordMessageHandler_TestCase(JCLTestCase):
def test_handle(self):
model.db_connect()
account11 = ExampleAccount(user_jid="user1@test.com",
user1 = User(jid="user1@test.com")
account11 = ExampleAccount(user=user1,
name="account11",
jid="account11@jcl.test.com")
account12 = ExampleAccount(user_jid="user1@test.com",
account12 = ExampleAccount(user=user1,
name="account12",
jid="account12@jcl.test.com")
message = Message(from_jid="user1@test.com",
@@ -129,9 +134,9 @@ class PasswordMessageHandler_TestCase(JCLTestCase):
model.db_disconnect()
def suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(PasswordMessageHandler_TestCase, 'test'))
return suite
test_suite = unittest.TestSuite()
test_suite.addTest(unittest.makeSuite(PasswordMessageHandler_TestCase, 'test'))
return test_suite
if __name__ == '__main__':
unittest.main(defaultTest='suite')

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

@@ -21,12 +21,22 @@
##
import unittest
import tempfile
import os
from ConfigParser import ConfigParser
from pyxmpp.presence import Presence
from pyxmpp.message import Message
from jcl.jabber.component import JCLComponent
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):
def setUp(self):
self.handler = DefaultSubscribeHandler(None)
@@ -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_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():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(DefaultSubscribeHandler_TestCase, 'test'))
suite.addTest(unittest.makeSuite(DefaultUnsubscribeHandler_TestCase, 'test'))
suite.addTest(unittest.makeSuite(DefaultPresenceHandler_TestCase, 'test'))
return suite
test_suite = unittest.TestSuite()
test_suite.addTest(unittest.makeSuite(DefaultSubscribeHandler_TestCase, 'test'))
test_suite.addTest(unittest.makeSuite(DefaultUnsubscribeHandler_TestCase, 'test'))
test_suite.addTest(unittest.makeSuite(DefaultPresenceHandler_TestCase, 'test'))
test_suite.addTest(unittest.makeSuite(RootPresenceAvailableHandler_TestCase, 'test'))
return test_suite
if __name__ == '__main__':
unittest.main(defaultTest='suite')

61
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
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):
"""Base Account class"""
_cacheValue = False
_connection = model.hub
user_jid = StringCol()
name = StringCol()
jid = StringCol()
_status = StringCol(default=OFFLINE, dbName="status")
@@ -71,7 +96,8 @@ class Account(InheritableSQLObject):
legacy_jids = MultipleJoin('LegacyJID')
enabled = BoolCol(default=True)
lastlogin = DateTimeCol(default=datetime.datetime.today())
user = ForeignKey("User")
## Use these attributs to support volatile password
## login = StringCol(default = "")
## password = StringCol(default = None)
@@ -148,8 +174,9 @@ def get_account(bare_user_jid, name, account_class=Account):
result = None
model.db_connect()
accounts = account_class.select(\
AND(account_class.q.name == name,
account_class.q.user_jid == unicode(bare_user_jid)))
AND(AND(Account.q.name == name,
Account.q.userID == User.q.id),
User.q.jid == unicode(bare_user_jid)))
if accounts.count() > 0:
result = accounts[0]
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):
model.db_connect()
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)
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)
if accounts.count() == 0:
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):
model.db_connect()
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()
return accounts_count
@@ -192,18 +222,6 @@ def get_all_accounts_count(account_class=Account, filter=None):
accounts_count = account_class.select(filter).count()
model.db_disconnect()
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):
DO_NOTHING = 0
@@ -333,8 +351,9 @@ class PresenceAccount(Account):
def get_legacy_jids(bare_to_jid):
model.db_connect()
legacy_jids = LegacyJID.select(\
AND(LegacyJID.q.accountID == Account.q.id,
Account.q.user_jid == bare_to_jid))
AND(AND(LegacyJID.q.accountID == Account.q.id,
Account.q.userID == User.q.id),
User.q.jid == bare_to_jid))
for legacy_jid in legacy_jids:
yield legacy_jid
model.db_disconnect()

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

@@ -28,7 +28,7 @@ from sqlobject import *
from jcl.error import FieldError
import jcl.model as model
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
@@ -118,7 +118,10 @@ class PresenceAccountExample(PresenceAccount):
lambda bare_from_jid: 43)]
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):
result = account.default_post_func("test", None, "user1@jcl.test.com")
self.assertEquals(result, "test")
@@ -162,6 +165,58 @@ class AccountModule_TestCase(unittest.TestCase):
self.assertEquals(account.mandatory_field("test", "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):
def test_get_register_fields(self):
@@ -187,12 +242,12 @@ class InheritableAccount_TestCase(JCLTestCase):
class Account_TestCase(InheritableAccount_TestCase):
def setUp(self):
JCLTestCase.setUp(self, tables=[Account, ExampleAccount])
JCLTestCase.setUp(self, tables=[User, Account, ExampleAccount])
self.account_class = Account
def test_set_status(self):
model.db_connect()
account11 = Account(user_jid="test1@test.com",
account11 = Account(user=User(jid="test1@test.com"),
name="account11",
jid="account11@jcl.test.com")
account11.status = account.OFFLINE
@@ -202,7 +257,7 @@ class Account_TestCase(InheritableAccount_TestCase):
def test_set_status_live_password(self):
model.db_connect()
account11 = ExampleAccount(user_jid="test1@test.com",
account11 = ExampleAccount(user=User(jid="test1@test.com"),
name="account11",
jid="account11@jcl.test.com",
login="mylogin",
@@ -219,11 +274,11 @@ class Account_TestCase(InheritableAccount_TestCase):
class PresenceAccount_TestCase(InheritableAccount_TestCase):
def setUp(self):
JCLTestCase.setUp(self, tables=[Account, PresenceAccount,
JCLTestCase.setUp(self, tables=[User, Account, PresenceAccount,
PresenceAccountExample])
model.db_connect()
self.account = PresenceAccountExample(\
user_jid="test1@test.com",
user=User(jid="test1@test.com"),
name="account11",
jid="account11@jcl.test.com")
model.db_disconnect()

21
src/jcl/runner.py
View File

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

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

@@ -21,10 +21,10 @@ class JCLTestCase(unittest.TestCase):
def setUp(self, 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):
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_connect()
for table in tables:
@@ -45,12 +45,12 @@ def suite():
from jcl.tests import lang, runner
from jcl.jabber import tests as jabber
from jcl.model import tests as model
suite = unittest.TestSuite()
suite.addTest(lang.suite())
suite.addTest(runner.suite())
suite.addTest(jabber.suite())
suite.addTest(model.suite())
return suite
test_suite = unittest.TestSuite()
test_suite.addTest(lang.suite())
test_suite.addTest(runner.suite())
test_suite.addTest(jabber.suite())
test_suite.addTest(model.suite())
return test_suite
if __name__ == '__main__':
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):
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.port, 5347)
self.assertEquals(self.runner.secret, "secret")
@@ -139,9 +139,9 @@ class JCLRunner_TestCase(unittest.TestCase):
self.assertNotEquals(self.runner._get_help(), None)
def suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(JCLRunner_TestCase, 'test'))
return suite
test_suite = unittest.TestSuite()
test_suite.addTest(unittest.makeSuite(JCLRunner_TestCase, 'test'))
return test_suite
if __name__ == '__main__':
unittest.main(defaultTest='suite')