diff --git a/conf/jcl.conf b/conf/jcl.conf index d97a80b..58996e9 100644 --- a/conf/jcl.conf +++ b/conf/jcl.conf @@ -17,5 +17,6 @@ db_url: %(type)s://%(host)s%(name)s [component] pid_file: /var/run/jabber/jcl.pid +#motd: "Message of the day" diff --git a/src/jcl/jabber/command.py b/src/jcl/jabber/command.py index 6b0431e..6199afa 100644 --- a/src/jcl/jabber/command.py +++ b/src/jcl/jabber/command.py @@ -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): diff --git a/src/jcl/jabber/component.py b/src/jcl/jabber/component.py index c7125f0..457b6f8 100644 --- a/src/jcl/jabber/component.py +++ b/src/jcl/jabber/component.py @@ -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 \ diff --git a/src/jcl/jabber/feeder.py b/src/jcl/jabber/feeder.py index f035d14..93b2cf4 100644 --- a/src/jcl/jabber/feeder.py +++ b/src/jcl/jabber/feeder.py @@ -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): diff --git a/src/jcl/jabber/presence.py b/src/jcl/jabber/presence.py index 090d62c..dae0be9 100644 --- a/src/jcl/jabber/presence.py +++ b/src/jcl/jabber/presence.py @@ -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): diff --git a/src/jcl/jabber/tests/command.py b/src/jcl/jabber/tests/command.py index 487f310..4d889c2 100644 --- a/src/jcl/jabber/tests/command.py +++ b/src/jcl/jabber/tests/command.py @@ -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 diff --git a/src/jcl/jabber/tests/component.py b/src/jcl/jabber/tests/component.py index 21be025..3dd4d6d 100644 --- a/src/jcl/jabber/tests/component.py +++ b/src/jcl/jabber/tests/component.py @@ -26,9 +26,6 @@ import unittest import threading import time import re -import tempfile - -from sqlobject.dbconnection import TheURIOpener from pyxmpp.jid import JID from pyxmpp.iq import Iq @@ -37,12 +34,12 @@ from pyxmpp.message import Message from pyxmpp.jabber.dataforms import Form from jcl.jabber import Handler -from jcl.jabber.component import JCLComponent +from jcl.jabber.component import JCLComponent, AccountManager from jcl.jabber.presence import DefaultSubscribeHandler, \ DefaultUnsubscribeHandler, DefaultPresenceHandler 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.lang import Lang from jcl.model.tests.account import ExampleAccount, Example2Account @@ -159,11 +156,12 @@ class JCLComponent_TestCase(JCLTestCase): ########################################################################### def setUp(self): JCLTestCase.setUp(self, tables=[Account, LegacyJID, ExampleAccount, - Example2Account]) + Example2Account, User]) self.comp = JCLComponent("jcl.test.com", "password", "localhost", - "5347") + "5347", + None) self.max_tick_count = 1 self.saved_time_handler = None @@ -288,13 +286,14 @@ class JCLComponent_TestCase(JCLTestCase): self.max_tick_count = 1 self.comp.handle_tick = self.__handle_tick_test_time_handler model.db_connect() - account11 = Account(user_jid="test1@test.com", + user1 = User(jid="test1@test.com") + account11 = Account(user=user1, name="account11", jid="account11@jcl.test.com") - account12 = Account(user_jid="test1@test.com", + account12 = Account(user=user1, name="account12", jid="account12@jcl.test.com") - account2 = Account(user_jid="test2@test.com", + account2 = Account(user=User(jid="test2@test.com"), name="account2", jid="account2@jcl.test.com") model.db_disconnect() @@ -307,45 +306,45 @@ class JCLComponent_TestCase(JCLTestCase): raise self.comp.queue.get(0) presence_sent = self.comp.stream.sent self.assertEqual(len(presence_sent), 5) - self.assertEqual(len([presence \ - for presence in presence_sent \ - if presence.get_to_jid() == "test1@test.com"]), \ - 3) + self.assertEqual(len([presence + for presence in presence_sent + if presence.get_to_jid() == "test1@test.com"]), + 3) self.assertEqual(\ - len([presence \ - for presence in presence_sent \ + len([presence + for presence in presence_sent if presence.get_from_jid() == \ - "jcl.test.com" \ - and presence.xpath_eval("@type")[0].get_content() \ - == "unavailable"]), \ + "jcl.test.com" + and presence.xpath_eval("@type")[0].get_content() + == "unavailable"]), 2) self.assertEqual(\ - len([presence \ - for presence in presence_sent \ + len([presence + for presence in presence_sent if presence.get_from_jid() == \ - "account11@jcl.test.com" \ + "account11@jcl.test.com" and presence.xpath_eval("@type")[0].get_content() \ - == "unavailable"]), \ + == "unavailable"]), 1) self.assertEqual(\ - len([presence \ - for presence in presence_sent \ + len([presence + for presence in presence_sent if presence.get_from_jid() == \ - "account12@jcl.test.com" \ + "account12@jcl.test.com" and presence.xpath_eval("@type")[0].get_content() \ - == "unavailable"]), \ + == "unavailable"]), 1) self.assertEqual(len([presence \ - for presence in presence_sent \ - if presence.get_to_jid() == "test2@test.com"]), \ + for presence in presence_sent + if presence.get_to_jid() == "test2@test.com"]), 2) self.assertEqual(\ - len([presence \ - for presence in presence_sent \ + len([presence + for presence in presence_sent if presence.get_from_jid() == \ - "account2@jcl.test.com" \ + "account2@jcl.test.com" and presence.xpath_eval("@type")[0].get_content() \ - == "unavailable"]), \ + == "unavailable"]), 1) ########################################################################### @@ -376,15 +375,16 @@ class JCLComponent_TestCase(JCLTestCase): def test_authenticated_send_probe(self): model.db_connect() - account11 = Account(user_jid = "test1@test.com", \ - name = "account11", \ - jid = "account11@jcl.test.com") - account12 = Account(user_jid = "test1@test.com", \ - name = "account12", \ - jid = "account12@jcl.test.com") - account2 = Account(user_jid = "test2@test.com", \ - name = "account2", \ - jid = "account2@jcl.test.com") + user1 = User(jid="test1@test.com") + account11 = Account(user=user1, + name="account11", + jid="account11@jcl.test.com") + account12 = Account(user=user1, + name="account12", + jid="account12@jcl.test.com") + account2 = Account(user=User(jid="test2@test.com"), + name="account2", + jid="account2@jcl.test.com") model.db_disconnect() self.comp.stream = MockStream() self.comp.authenticated() @@ -396,18 +396,18 @@ class JCLComponent_TestCase(JCLTestCase): self.assertEquals(presence.get_node().prop("type"), "probe") presence = self.comp.stream.sent[1] self.assertTrue(isinstance(presence, Presence)) - self.assertEquals(presence.get_from(), "account11@jcl.test.com") - self.assertEquals(presence.get_to(), "test1@test.com") + self.assertEquals(presence.get_from(), "jcl.test.com") + self.assertEquals(presence.get_to(), "test2@test.com") self.assertEquals(presence.get_node().prop("type"), "probe") presence = self.comp.stream.sent[2] self.assertTrue(isinstance(presence, Presence)) - self.assertEquals(presence.get_from(), "account12@jcl.test.com") + self.assertEquals(presence.get_from(), "account11@jcl.test.com") self.assertEquals(presence.get_to(), "test1@test.com") self.assertEquals(presence.get_node().prop("type"), "probe") presence = self.comp.stream.sent[3] self.assertTrue(isinstance(presence, Presence)) - self.assertEquals(presence.get_from(), "jcl.test.com") - self.assertEquals(presence.get_to(), "test2@test.com") + self.assertEquals(presence.get_from(), "account12@jcl.test.com") + self.assertEquals(presence.get_to(), "test1@test.com") self.assertEquals(presence.get_node().prop("type"), "probe") presence = self.comp.stream.sent[4] self.assertTrue(isinstance(presence, Presence)) @@ -429,8 +429,8 @@ class JCLComponent_TestCase(JCLTestCase): def test_handle_get_gateway(self): self.comp.stream = MockStream() self.comp.stream_class = MockStream - info_query = Iq(stanza_type = "get", - from_jid = "user1@test.com") + info_query = Iq(stanza_type="get", + from_jid="user1@test.com") info_query.new_query("jabber:iq:gateway") self.comp.handle_get_gateway(info_query) self.assertEquals(len(self.comp.stream.sent), 1) @@ -452,8 +452,8 @@ class JCLComponent_TestCase(JCLTestCase): def test_handle_set_gateway(self): self.comp.stream = MockStream() self.comp.stream_class = MockStream - info_query = Iq(stanza_type = "get", - from_jid = "user1@test.com") + info_query = Iq(stanza_type="get", + from_jid="user1@test.com") query = info_query.new_query("jabber:iq:gateway") prompt = query.newChild(None, "prompt", None) prompt.addContent("user@test.com") @@ -550,13 +550,13 @@ class JCLComponent_TestCase(JCLTestCase): model.db_connect() self.comp.stream = MockStream() self.comp.stream_class = MockStream - account1 = Account(user_jid = "user1@test.com", \ - name = "account1", \ - jid = "account1@jcl.test.com") + account1 = Account(user=User(jid="user1@test.com"), + name="account1", + jid="account1@jcl.test.com") model.db_disconnect() - info_query = Iq(stanza_type = "get", \ - from_jid = "user1@test.com", \ - to_jid = "jcl.test.com") + info_query = Iq(stanza_type="get", + from_jid="user1@test.com", + to_jid="jcl.test.com") disco_items = self.comp.disco_get_items(None, info_query) self.assertEquals(len(disco_items.get_items()), 1) disco_item = disco_items.get_items()[0] @@ -567,7 +567,7 @@ class JCLComponent_TestCase(JCLTestCase): def test_disco_get_items_unknown_node(self): self.comp.account_manager.account_classes = (ExampleAccount, ) 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") model.db_disconnect() @@ -580,10 +580,11 @@ class JCLComponent_TestCase(JCLTestCase): def test_disco_get_items_unknown_node_multiple_account_types(self): self.comp.account_manager.account_classes = (ExampleAccount, Example2Account) 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") - account21 = Example2Account(user_jid="user1@test.com", + account21 = Example2Account(user=user1, name="account21", jid="account21@jcl.test.com") model.db_disconnect() @@ -597,7 +598,7 @@ class JCLComponent_TestCase(JCLTestCase): def test_disco_get_items_1type_with_node(self): """get_items on an account. Must return nothing""" model.db_connect() - account1 = Account(user_jid="user1@test.com", + account1 = Account(user=User(jid="user1@test.com"), name="account1", jid="account1@jcl.test.com") model.db_disconnect() @@ -614,10 +615,11 @@ class JCLComponent_TestCase(JCLTestCase): self.comp.stream = MockStream() self.comp.stream_class = MockStream 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") - account21 = Example2Account(user_jid="user1@test.com", + account21 = Example2Account(user=user1, name="account21", jid="account21@jcl.test.com") model.db_disconnect() @@ -648,16 +650,18 @@ class JCLComponent_TestCase(JCLTestCase): self.comp.stream = MockStream() self.comp.stream_class = MockStream model.db_connect() - account11 = ExampleAccount(user_jid="user1@test.com", + user1 = User(jid="user1@test.com") + user2 = User(jid="user2@test.com") + account11 = ExampleAccount(user=user1, name="account11", jid="account11@jcl.test.com") - account12 = ExampleAccount(user_jid="user2@test.com", + account12 = ExampleAccount(user=user2, name="account12", jid="account12@jcl.test.com") - account21 = Example2Account(user_jid="user1@test.com", + account21 = Example2Account(user=user1, name="account21", jid="account21@jcl.test.com") - account22 = Example2Account(user_jid="user2@test.com", + account22 = Example2Account(user=user2, name="account22", jid="account22@jcl.test.com") model.db_disconnect() @@ -678,16 +682,18 @@ class JCLComponent_TestCase(JCLTestCase): self.comp.stream = MockStream() self.comp.stream_class = MockStream model.db_connect() - account11 = ExampleAccount(user_jid="user1@test.com", + user1 = User(jid="user1@test.com") + user2 = User(jid="user2@test.com") + account11 = ExampleAccount(user=user1, name="account11", jid="account11@jcl.test.com") - account12 = ExampleAccount(user_jid="user2@test.com", + account12 = ExampleAccount(user=user2, name="account12", jid="account12@jcl.test.com") - account21 = Example2Account(user_jid="user1@test.com", + account21 = Example2Account(user=user1, name="account21", jid="account21@jcl.test.com") - account22 = Example2Account(user_jid="user2@test.com", + account22 = Example2Account(user=user2, name="account22", jid="account22@jcl.test.com") model.db_disconnect() @@ -705,7 +711,7 @@ class JCLComponent_TestCase(JCLTestCase): """get_items on a first type account. Must return nothing""" self.comp.account_manager.account_classes = (ExampleAccount, Example2Account) model.db_connect() - account1 = ExampleAccount(user_jid="user1@test.com", + account1 = ExampleAccount(user=User(jid="user1@test.com"), name="account1", jid="account1@jcl.test.com") model.db_disconnect() @@ -719,7 +725,7 @@ class JCLComponent_TestCase(JCLTestCase): """get_items on a second type account. Must return nothing""" self.comp.account_manager.account_classes = (ExampleAccount, Example2Account) model.db_connect() - account1 = Example2Account(user_jid="user1@test.com", + account1 = Example2Account(user=User(jid="user1@test.com"), name="account1", jid="account1@jcl.test.com") model.db_disconnect() @@ -869,13 +875,14 @@ class JCLComponent_TestCase(JCLTestCase): 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") - account21 = Account(user_jid="user1@test.com", + account21 = Account(user=User(jid="user2@test.com"), name="account21", jid="account21@jcl.test.com") model.db_disconnect() @@ -915,51 +922,52 @@ class JCLComponent_TestCase(JCLTestCase): model.db_connect() self.comp.stream = MockStream() self.comp.stream_class = MockStream - account1 = ExampleAccount(user_jid = "user1@test.com", \ - name = "account1", \ - jid = "account1@jcl.test.com", \ - login = "mylogin", \ - password = "mypassword", \ - store_password = False, \ - test_enum = "choice3", \ - test_int = 1) - account11 = ExampleAccount(user_jid = "user1@test.com", \ - name = "account11", \ - jid = "account11@jcl.test.com", \ - login = "mylogin11", \ - password = "mypassword11", \ - store_password = False, \ - test_enum = "choice2", \ - test_int = 11) - account21 = ExampleAccount(user_jid = "user2@test.com", \ - name = "account21", \ - jid = "account21@jcl.test.com", \ - login = "mylogin21", \ - password = "mypassword21", \ - store_password = False, \ - test_enum = "choice1", \ - test_int = 21) + user1 = User(jid="user1@test.com") + account1 = ExampleAccount(user=user1, + name="account1", + jid="account1@jcl.test.com", + login="mylogin", + password="mypassword", + store_password=False, + test_enum="choice3", + test_int=1) + account11 = ExampleAccount(user=user1, + name="account11", + jid="account11@jcl.test.com", + login="mylogin11", + password="mypassword11", + store_password=False, + test_enum="choice2", + test_int=11) + account21 = ExampleAccount(user=User(jid="user2@test.com"), + name="account21", + jid="account21@jcl.test.com", + login="mylogin21", + password="mypassword21", + store_password=False, + test_enum="choice1", + test_int=21) model.db_disconnect() - self.comp.handle_get_register(Iq(stanza_type = "get", \ - from_jid = "user1@test.com", \ - to_jid = "account1@jcl.test.com")) + self.comp.handle_get_register(Iq(stanza_type="get", + from_jid="user1@test.com", + to_jid="account1@jcl.test.com")) self.assertEquals(len(self.comp.stream.sent), 1) iq_sent = self.comp.stream.sent[0] self.assertEquals(iq_sent.get_to(), "user1@test.com") - titles = iq_sent.xpath_eval("jir:query/jxd:x/jxd:title", \ - {"jir" : "jabber:iq:register", \ + titles = iq_sent.xpath_eval("jir:query/jxd:x/jxd:title", + {"jir" : "jabber:iq:register", "jxd" : "jabber:x:data"}) self.assertEquals(len(titles), 1) - self.assertEquals(titles[0].content, \ + self.assertEquals(titles[0].content, Lang.en.register_title) - instructions = iq_sent.xpath_eval("jir:query/jxd:x/jxd:instructions", \ - {"jir" : "jabber:iq:register", \ + instructions = iq_sent.xpath_eval("jir:query/jxd:x/jxd:instructions", + {"jir" : "jabber:iq:register", "jxd" : "jabber:x:data"}) self.assertEquals(len(instructions), 1) - self.assertEquals(instructions[0].content, \ + self.assertEquals(instructions[0].content, Lang.en.register_instructions) - fields = iq_sent.xpath_eval("jir:query/jxd:x/jxd:field", \ - {"jir" : "jabber:iq:register", \ + fields = iq_sent.xpath_eval("jir:query/jxd:x/jxd:field", + {"jir" : "jabber:iq:register", "jxd" : "jabber:x:data"}) self.assertEquals(len(fields), 6) field = fields[0] @@ -995,8 +1003,8 @@ class JCLComponent_TestCase(JCLTestCase): self.assertEquals(field.children.name, "value") self.assertEquals(field.children.content, "choice3") # TODO : correct xpath expression (field[4]) - options = iq_sent.xpath_eval("jir:query/jxd:x/jxd:field/jxd:option", \ - {"jir" : "jabber:iq:register", \ + options = iq_sent.xpath_eval("jir:query/jxd:x/jxd:field/jxd:option", + {"jir" : "jabber:iq:register", "jxd" : "jabber:x:data"}) self.assertEquals(options[0].prop("label"), "choice1") @@ -1020,35 +1028,35 @@ class JCLComponent_TestCase(JCLTestCase): self.comp.stream = MockStream() self.comp.stream_class = MockStream self.comp.account_manager.account_classes = (ExampleAccount, Example2Account) - self.comp.handle_get_register(Iq(stanza_type = "get", \ - from_jid = "user1@test.com", \ - to_jid = "jcl.test.com/example")) + self.comp.handle_get_register(Iq(stanza_type="get", + from_jid="user1@test.com", + to_jid="jcl.test.com/example")) self.__check_get_register_new_type() def test_handle_get_register_new_type2(self): self.comp.stream = MockStream() self.comp.stream_class = MockStream self.comp.account_manager.account_classes = (ExampleAccount, Example2Account) - self.comp.handle_get_register(Iq(stanza_type = "get", \ - from_jid = JID("user1@test.com"), \ - to_jid = JID("jcl.test.com/example2"))) + self.comp.handle_get_register(Iq(stanza_type="get", + from_jid=JID("user1@test.com"), + to_jid=JID("jcl.test.com/example2"))) self.assertEquals(len(self.comp.stream.sent), 1) iq_sent = self.comp.stream.sent[0] self.assertEquals(iq_sent.get_to(), "user1@test.com") - titles = iq_sent.xpath_eval("jir:query/jxd:x/jxd:title", \ - {"jir" : "jabber:iq:register", \ + titles = iq_sent.xpath_eval("jir:query/jxd:x/jxd:title", + {"jir" : "jabber:iq:register", "jxd" : "jabber:x:data"}) self.assertEquals(len(titles), 1) - self.assertEquals(titles[0].content, \ + self.assertEquals(titles[0].content, Lang.en.register_title) - instructions = iq_sent.xpath_eval("jir:query/jxd:x/jxd:instructions", \ - {"jir" : "jabber:iq:register", \ + instructions = iq_sent.xpath_eval("jir:query/jxd:x/jxd:instructions", + {"jir" : "jabber:iq:register", "jxd" : "jabber:x:data"}) self.assertEquals(len(instructions), 1) - self.assertEquals(instructions[0].content, \ + self.assertEquals(instructions[0].content, Lang.en.register_instructions) - fields = iq_sent.xpath_eval("jir:query/jxd:x/jxd:field", \ - {"jir" : "jabber:iq:register", \ + fields = iq_sent.xpath_eval("jir:query/jxd:x/jxd:field", + {"jir" : "jabber:iq:register", "jxd" : "jabber:x:data"}) self.assertEquals(len(fields), 2) self.assertEquals(fields[0].prop("type"), "text-single") @@ -1080,7 +1088,7 @@ class JCLComponent_TestCase(JCLTestCase): model.db_connect() _account = account.get_account("user1@test.com", "account1") self.assertNotEquals(_account, None) - self.assertEquals(_account.user_jid, "user1@test.com") + self.assertEquals(_account.user.jid, "user1@test.com") self.assertEquals(_account.name, "account1") self.assertEquals(_account.jid, "account1@jcl.test.com") model.db_disconnect() @@ -1134,7 +1142,7 @@ class JCLComponent_TestCase(JCLTestCase): model.db_connect() _account = account.get_account("user1@test.com", "account1") self.assertNotEquals(_account, None) - self.assertEquals(_account.user_jid, "user1@test.com") + self.assertEquals(_account.user.jid, "user1@test.com") self.assertEquals(_account.name, "account1") self.assertEquals(_account.jid, "account1@jcl.test.com") model.db_disconnect() @@ -1203,7 +1211,7 @@ class JCLComponent_TestCase(JCLTestCase): model.db_connect() _account = account.get_account("user1@test.com", "account1") self.assertNotEquals(_account, None) - self.assertEquals(_account.user_jid, "user1@test.com") + self.assertEquals(_account.user.jid, "user1@test.com") self.assertEquals(_account.name, "account1") self.assertEquals(_account.jid, "account1@jcl.test.com") self.assertEquals(_account.login, "mylogin") @@ -1265,7 +1273,7 @@ class JCLComponent_TestCase(JCLTestCase): model.db_connect() _account = account.get_account("user1@test.com", "account1") self.assertNotEquals(_account, None) - self.assertEquals(_account.user_jid, "user1@test.com") + self.assertEquals(_account.user.jid, "user1@test.com") self.assertEquals(_account.name, "account1") self.assertEquals(_account.jid, "account1@jcl.test.com") self.assertEquals(_account.login, "mylogin") @@ -1336,45 +1344,46 @@ class JCLComponent_TestCase(JCLTestCase): self.comp.stream = MockStream() self.comp.stream_class = MockStream self.comp.account_manager.account_classes = (Example2Account, ExampleAccount) - existing_account = ExampleAccount(user_jid = "user1@test.com", \ - name = "account1", \ - jid = "account1@jcl.test.com", \ - login = "mylogin", \ - password = "mypassword", \ - store_password = True, \ - test_enum = "choice1", \ - test_int = 21) - another_account = ExampleAccount(user_jid = "user1@test.com", \ - name = "account2", \ - jid = "account2@jcl.test.com", \ - login = "mylogin", \ - password = "mypassword", \ - store_password = True, \ - test_enum = "choice1", \ - test_int = 21) + user1 = User(jid="user1@test.com") + existing_account = ExampleAccount(user=user1, + name="account1", + jid="account1@jcl.test.com", + login="mylogin", + password="mypassword", + store_password=True, + test_enum="choice1", + test_int=21) + another_account = ExampleAccount(user=user1, + name="account2", + jid="account2@jcl.test.com", + login="mylogin", + password="mypassword", + store_password=True, + test_enum="choice1", + test_int=21) model.db_disconnect() x_data = Form("submit") - x_data.add_field(name = "name", \ - value = "account1", \ - field_type = "text-single") - x_data.add_field(name = "login", \ - value = "mylogin2", \ - field_type = "text-single") - x_data.add_field(name = "password", \ - value = "mypassword2", \ - field_type = "text-private") - x_data.add_field(name = "store_password", \ - value = False, \ - field_type = "boolean") - x_data.add_field(name = "test_enum", \ - value = "choice3", \ - field_type = "list-single") - x_data.add_field(name = "test_int", \ - value = 43, \ - field_type = "text-single") - iq_set = Iq(stanza_type = "set", \ - from_jid = "user1@test.com", \ - to_jid = "account1@jcl.test.com") + x_data.add_field(name="name", + value="account1", + field_type="text-single") + x_data.add_field(name="login", + value="mylogin2", + field_type="text-single") + x_data.add_field(name="password", + value="mypassword2", + field_type="text-private") + x_data.add_field(name="store_password", + value=False, + field_type="boolean") + x_data.add_field(name="test_enum", + value="choice3", + field_type="list-single") + x_data.add_field(name="test_int", + value=43, + field_type="text-single") + iq_set = Iq(stanza_type="set", + from_jid="user1@test.com", + to_jid="account1@jcl.test.com") query = iq_set.new_query("jabber:iq:register") x_data.as_xml(query) self.comp.handle_set_register(iq_set) @@ -1383,7 +1392,7 @@ class JCLComponent_TestCase(JCLTestCase): _account = account.get_account("user1@test.com", "account1") self.assertNotEquals(_account, None) self.assertEquals(_account.__class__.__name__, "ExampleAccount") - self.assertEquals(_account.user_jid, "user1@test.com") + self.assertEquals(_account.user.jid, "user1@test.com") self.assertEquals(_account.name, "account1") self.assertEquals(_account.jid, "account1@jcl.test.com") self.assertEquals(_account.login, "mylogin2") @@ -1414,13 +1423,14 @@ class JCLComponent_TestCase(JCLTestCase): 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="account1", jid="account1@jcl.test.com") - account12 = Account(user_jid="user1@test.com", + account12 = Account(user=user1, name="account2", jid="account2@jcl.test.com") - account21 = Account(user_jid="user2@test.com", + account21 = Account(user=User(jid="user2@test.com"), name="account1", jid="account1@jcl.test.com") model.db_disconnect() @@ -1439,7 +1449,7 @@ class JCLComponent_TestCase(JCLTestCase): for _account in accounts: i = i + 1 self.assertEquals(i, 1) - 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() @@ -1481,60 +1491,62 @@ class JCLComponent_TestCase(JCLTestCase): self.comp.stream = MockStream() self.comp.stream_class = MockStream model.db_connect() - account11 = Account(user_jid = "user1@test.com", \ - name = "account11", \ - jid = "account11@jcl.test.com") - account12 = Account(user_jid = "user1@test.com", \ - name = "account12", \ - jid = "account12@jcl.test.com") - account2 = Account(user_jid = "user2@test.com", \ - name = "account2", \ - jid = "account2@jcl.test.com") + 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") + account2 = Account(user=User(jid="user2@test.com"), + name="account2", + jid="account2@jcl.test.com") model.db_disconnect() self.comp.handle_presence_available(Presence(\ - stanza_type = "available", \ - from_jid = "user1@test.com",\ - to_jid = "jcl.test.com")) + stanza_type="available", + from_jid="user1@test.com", + to_jid="jcl.test.com")) presence_sent = self.comp.stream.sent self.assertEqual(len(presence_sent), 3) - self.assertEqual(len([presence \ - for presence in presence_sent \ + self.assertEqual(len([presence + for presence in presence_sent if presence.get_to_jid() == "user1@test.com" \ - and presence.get_type() is None]), \ + and presence.get_type() is None]), 3) - self.assertEqual(len([presence \ - for presence in presence_sent \ + self.assertEqual(len([presence + for presence in presence_sent if presence.get_from_jid() == \ "jcl.test.com" \ and isinstance(presence, Presence) \ - and presence.get_type() is None]), \ + and presence.get_type() is None]), 1) - self.assertEqual(len([presence \ - for presence in presence_sent \ + self.assertEqual(len([presence + for presence in presence_sent if presence.get_from_jid() == \ "account11@jcl.test.com" \ and isinstance(presence, Presence) \ - and presence.get_type() is None]), \ + and presence.get_type() is None]), 1) - self.assertEqual(len([presence \ - for presence in presence_sent \ + self.assertEqual(len([presence + for presence in presence_sent if presence.get_from_jid() == \ "account12@jcl.test.com" \ and isinstance(presence, Presence) \ - and presence.get_type() is None]), \ + and presence.get_type() is None]), 1) def test_handle_presence_available_to_component_legacy_users(self): 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") legacy_jid111 = LegacyJID(legacy_address="u111@test.com", @@ -1618,20 +1630,21 @@ class JCLComponent_TestCase(JCLTestCase): self.comp.stream = MockStream() self.comp.stream_class = MockStream model.db_connect() - account11 = Account(user_jid = "user1@test.com", \ - name = "account11", \ - jid = "account11@jcl.test.com") - account12 = Account(user_jid = "user1@test.com", \ - name = "account12", \ - jid = "account12@jcl.test.com") - account2 = Account(user_jid = "user2@test.com", \ - name = "account2", \ - jid = "account2@jcl.test.com") + 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") + account2 = Account(user=User(jid="user2@test.com"), + name="account2", + jid="account2@jcl.test.com") model.db_disconnect() self.comp.handle_presence_available(Presence(\ - stanza_type = "available", \ - from_jid = "unknown@test.com",\ - to_jid = "jcl.test.com")) + stanza_type="available", + from_jid="unknown@test.com", + to_jid="jcl.test.com")) presence_sent = self.comp.stream.sent self.assertEqual(len(presence_sent), 0) @@ -1639,20 +1652,21 @@ class JCLComponent_TestCase(JCLTestCase): self.comp.stream = MockStream() self.comp.stream_class = MockStream model.db_connect() - account11 = Account(user_jid = "user1@test.com", \ - name = "account11", \ - jid = "account11@jcl.test.com") - account12 = Account(user_jid = "user1@test.com", \ - name = "account12", \ - jid = "account12@jcl.test.com") - account2 = Account(user_jid = "user2@test.com", \ - name = "account2", \ - jid = "account2@jcl.test.com") + 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") + account2 = Account(user=User(jid="user2@test.com"), + name="account2", + jid="account2@jcl.test.com") model.db_disconnect() self.comp.handle_presence_available(Presence(\ - stanza_type = "available", \ - from_jid = "user1@test.com",\ - to_jid = "account11@jcl.test.com")) + stanza_type="available", + from_jid="user1@test.com", + to_jid="account11@jcl.test.com")) presence_sent = self.comp.stream.sent self.assertEqual(len(presence_sent), 1) self.assertEqual(presence_sent[0].get_to(), "user1@test.com") @@ -1665,13 +1679,14 @@ class JCLComponent_TestCase(JCLTestCase): self.comp.stream_class = MockStream self.comp.presence_available_handlers += [(DefaultPresenceHandler(self.comp),)] 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") model.db_disconnect() @@ -1691,20 +1706,21 @@ class JCLComponent_TestCase(JCLTestCase): self.comp.stream = MockStream() self.comp.stream_class = MockStream model.db_connect() - account11 = Account(user_jid = "user1@test.com", \ - name = "account11", \ - jid = "account11@jcl.test.com") - account12 = Account(user_jid = "user1@test.com", \ - name = "account12", \ - jid = "account12@jcl.test.com") - account2 = Account(user_jid = "user2@test.com", \ - name = "account2", \ - jid = "account2@jcl.test.com") + 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") + account2 = Account(user=User(jid="user2@test.com"), + name="account2", + jid="account2@jcl.test.com") model.db_disconnect() self.comp.handle_presence_available(Presence(\ - stanza_type = "available", \ - from_jid = "unknown@test.com",\ - to_jid = "account11@jcl.test.com")) + stanza_type="available", + from_jid="unknown@test.com", + to_jid="account11@jcl.test.com")) presence_sent = self.comp.stream.sent self.assertEqual(len(presence_sent), 0) @@ -1712,20 +1728,21 @@ class JCLComponent_TestCase(JCLTestCase): self.comp.stream = MockStream() self.comp.stream_class = MockStream model.db_connect() - account11 = Account(user_jid = "user1@test.com", \ - name = "account11", \ - jid = "account11@jcl.test.com") - account12 = Account(user_jid = "user1@test.com", \ - name = "account12", \ - jid = "account12@jcl.test.com") - account2 = Account(user_jid = "user2@test.com", \ - name = "account2", \ - jid = "account2@jcl.test.com") + 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") + account2 = Account(user=User(jid="user2@test.com"), + name="account2", + jid="account2@jcl.test.com") model.db_disconnect() self.comp.handle_presence_available(Presence(\ - stanza_type = "available", \ - from_jid = "user1@test.com",\ - to_jid = "unknown@jcl.test.com")) + stanza_type="available", + from_jid="user1@test.com", + to_jid="unknown@jcl.test.com")) presence_sent = self.comp.stream.sent self.assertEqual(len(presence_sent), 0) @@ -1733,21 +1750,22 @@ class JCLComponent_TestCase(JCLTestCase): self.comp.stream = MockStream() self.comp.stream_class = MockStream model.db_connect() - account11 = Account(user_jid = "user1@test.com", \ - name = "account11", \ - jid = "account11@jcl.test.com") + user1 = User(jid="user1@test.com") + account11 = Account(user=user1, + name="account11", + jid="account11@jcl.test.com") account11.store_password = False - account12 = Account(user_jid = "user1@test.com", \ - name = "account12", \ - jid = "account12@jcl.test.com") - account2 = Account(user_jid = "user2@test.com", \ - name = "account2", \ - jid = "account2@jcl.test.com") + account12 = Account(user=user1, + name="account12", + jid="account12@jcl.test.com") + account2 = Account(user=User(jid="user2@test.com"), + name="account2", + jid="account2@jcl.test.com") model.db_disconnect() self.comp.handle_presence_available(Presence(\ - stanza_type = "available", \ - from_jid = "user1@test.com",\ - to_jid = "account11@jcl.test.com")) + stanza_type="available", + from_jid="user1@test.com", + to_jid="account11@jcl.test.com")) messages_sent = self.comp.stream.sent self.assertEqual(len(messages_sent), 1) presence = messages_sent[0] @@ -1761,21 +1779,22 @@ class JCLComponent_TestCase(JCLTestCase): model.db_connect() self.comp.stream = MockStream() self.comp.stream_class = MockStream - account11 = ExampleAccount(user_jid = "user1@test.com", \ - name = "account11", \ - jid = "account11@jcl.test.com") + user1 = User(jid="user1@test.com") + account11 = ExampleAccount(user=user1, + name="account11", + jid="account11@jcl.test.com") account11.store_password = False - account12 = ExampleAccount(user_jid = "user1@test.com", \ - name = "account12", \ - jid = "account12@jcl.test.com") - account2 = ExampleAccount(user_jid = "user2@test.com", \ - name = "account2", \ - jid = "account2@jcl.test.com") + account12 = ExampleAccount(user=user1, + name="account12", + jid="account12@jcl.test.com") + account2 = ExampleAccount(user=User(jid="user2@test.com"), + name="account2", + jid="account2@jcl.test.com") model.db_disconnect() self.comp.handle_presence_available(Presence(\ - stanza_type = "available", \ - from_jid = "user1@test.com",\ - to_jid = "account11@jcl.test.com")) + stanza_type="available", + from_jid="user1@test.com", + to_jid="account11@jcl.test.com")) messages_sent = self.comp.stream.sent self.assertEqual(len(messages_sent), 2) password_message = None @@ -1805,63 +1824,65 @@ class JCLComponent_TestCase(JCLTestCase): self.comp.stream = MockStream() self.comp.stream_class = MockStream model.db_connect() - account11 = Account(user_jid = "user1@test.com", \ - name = "account11", \ - jid = "account11@jcl.test.com") - account12 = Account(user_jid = "user1@test.com", \ - name = "account12", \ - jid = "account12@jcl.test.com") - account2 = Account(user_jid = "user2@test.com", \ - name = "account2", \ - jid = "account2@jcl.test.com") + 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") + account2 = Account(user=User(jid="user2@test.com"), + name="account2", + jid="account2@jcl.test.com") model.db_disconnect() self.comp.handle_presence_unavailable(Presence(\ - stanza_type = "unavailable", \ - from_jid = "user1@test.com",\ - to_jid = "jcl.test.com")) + stanza_type="unavailable", + from_jid="user1@test.com", + to_jid="jcl.test.com")) presence_sent = self.comp.stream.sent self.assertEqual(len(presence_sent), 3) - self.assertEqual(len([presence \ - for presence in presence_sent \ + self.assertEqual(len([presence + for presence in presence_sent if presence.get_to_jid() == "user1@test.com" \ - and presence.get_type() == "unavailable"]), \ + and presence.get_type() == "unavailable"]), 3) self.assertEqual(\ - len([presence \ - for presence in presence_sent \ + len([presence + for presence in presence_sent if presence.get_from_jid() == \ "jcl.test.com" \ and presence.xpath_eval("@type")[0].get_content() \ - == "unavailable"]), \ + == "unavailable"]), 1) self.assertEqual(\ - len([presence \ - for presence in presence_sent \ + len([presence + for presence in presence_sent if presence.get_from_jid() == \ "account11@jcl.test.com" \ and presence.xpath_eval("@type")[0].get_content() \ - == "unavailable"]), \ + == "unavailable"]), 1) self.assertEqual(\ - len([presence \ - for presence in presence_sent \ + len([presence + for presence in presence_sent if presence.get_from_jid() == \ "account12@jcl.test.com" \ and presence.xpath_eval("@type")[0].get_content() \ - == "unavailable"]), \ + == "unavailable"]), 1) def test_handle_presence_unavailable_to_component_legacy_users(self): 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") legacy_jid111 = LegacyJID(legacy_address="u111@test.com", @@ -1945,20 +1966,21 @@ class JCLComponent_TestCase(JCLTestCase): self.comp.stream = MockStream() self.comp.stream_class = MockStream model.db_connect() - account11 = Account(user_jid = "user1@test.com", \ - name = "account11", \ - jid = "account11@jcl.test.com") - account12 = Account(user_jid = "user1@test.com", \ - name = "account12", \ - jid = "account12@jcl.test.com") - account2 = Account(user_jid = "user2@test.com", \ - name = "account2", \ - jid = "account2@jcl.test.com") + 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") + account2 = Account(user=User(jid="user2@test.com"), + name="account2", + jid="account2@jcl.test.com") model.db_disconnect() self.comp.handle_presence_unavailable(Presence(\ - stanza_type = "unavailable", \ - from_jid = "unknown@test.com",\ - to_jid = "jcl.test.com")) + stanza_type="unavailable", + from_jid="unknown@test.com", + to_jid="jcl.test.com")) presence_sent = self.comp.stream.sent self.assertEqual(len(presence_sent), 0) @@ -1966,13 +1988,14 @@ class JCLComponent_TestCase(JCLTestCase): 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") model.db_disconnect() @@ -1993,46 +2016,48 @@ class JCLComponent_TestCase(JCLTestCase): self.comp.stream_class = MockStream self.comp.presence_unavailable_handlers += [(DefaultPresenceHandler(self.comp),)] model.db_connect() - account11 = Account(user_jid = "user1@test.com", \ - name = "account11", \ - jid = "account11@jcl.test.com") - account12 = Account(user_jid = "user1@test.com", \ - name = "account12", \ - jid = "account12@jcl.test.com") - account2 = Account(user_jid = "user2@test.com", \ - name = "account2", \ - jid = "account2@jcl.test.com") + 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") + account2 = Account(user=User(jid="user2@test.com"), + name="account2", + jid="account2@jcl.test.com") model.db_disconnect() self.comp.handle_presence_unavailable(Presence(\ - stanza_type = "unavailable", \ - from_jid = "user1@test.com",\ - to_jid = "user1%test.com@jcl.test.com")) + stanza_type="unavailable", + from_jid="user1@test.com", + to_jid="user1%test.com@jcl.test.com")) presence_sent = self.comp.stream.sent self.assertEqual(len(presence_sent), 1) self.assertEqual(presence_sent[0].get_to(), "user1@test.com") self.assertEqual(presence_sent[0].get_from(), "user1%test.com@jcl.test.com") self.assertEqual(\ - presence_sent[0].xpath_eval("@type")[0].get_content(), \ + presence_sent[0].xpath_eval("@type")[0].get_content(), "unavailable") def test_handle_presence_unavailable_to_account_unknown_user(self): self.comp.stream = MockStream() self.comp.stream_class = MockStream model.db_connect() - account11 = Account(user_jid = "user1@test.com", \ - name = "account11", \ - jid = "account11@jcl.test.com") - account12 = Account(user_jid = "user1@test.com", \ - name = "account12", \ - jid = "account12@jcl.test.com") - account2 = Account(user_jid = "user2@test.com", \ - name = "account2", \ - jid = "account2@jcl.test.com") + 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") + account2 = Account(user=User(jid="user2@test.com"), + name="account2", + jid="account2@jcl.test.com") model.db_disconnect() self.comp.handle_presence_unavailable(Presence(\ - stanza_type = "unavailable", \ - from_jid = "unknown@test.com",\ - to_jid = "account11@jcl.test.com")) + stanza_type="unavailable", + from_jid="unknown@test.com", + to_jid="account11@jcl.test.com")) presence_sent = self.comp.stream.sent self.assertEqual(len(presence_sent), 0) @@ -2040,20 +2065,21 @@ class JCLComponent_TestCase(JCLTestCase): self.comp.stream = MockStream() self.comp.stream_class = MockStream model.db_connect() - account11 = Account(user_jid = "user1@test.com", \ - name = "account11", \ - jid = "account11@jcl.test.com") - account12 = Account(user_jid = "user1@test.com", \ - name = "account12", \ - jid = "account12@jcl.test.com") - account2 = Account(user_jid = "user2@test.com", \ - name = "account2", \ - jid = "account2@jcl.test.com") + 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") + account2 = Account(user=User(jid="user2@test.com"), + name="account2", + jid="account2@jcl.test.com") model.db_disconnect() self.comp.handle_presence_unavailable(Presence(\ - stanza_type = "unavailable", \ - from_jid = "user1@test.com",\ - to_jid = "unknown@jcl.test.com")) + stanza_type="unavailable", + from_jid="user1@test.com", + to_jid="unknown@jcl.test.com")) presence_sent = self.comp.stream.sent self.assertEqual(len(presence_sent), 0) @@ -2061,39 +2087,41 @@ class JCLComponent_TestCase(JCLTestCase): self.comp.stream = MockStream() self.comp.stream_class = MockStream model.db_connect() - account11 = Account(user_jid = "user1@test.com", \ - name = "account11", \ - jid = "account11@jcl.test.com") - account12 = Account(user_jid = "user1@test.com", \ - name = "account12", \ - jid = "account12@jcl.test.com") - account2 = Account(user_jid = "user2@test.com", \ - name = "account2", \ - jid = "account2@jcl.test.com") + 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") + account2 = Account(user=User(jid="user2@test.com"), + name="account2", + jid="account2@jcl.test.com") model.db_disconnect() self.comp.handle_presence_subscribe(Presence(\ - stanza_type = "subscribe", \ - from_jid = "user1@test.com",\ - to_jid = "jcl.test.com")) + stanza_type="subscribe", + from_jid="user1@test.com", + to_jid="jcl.test.com")) presence_sent = self.comp.stream.sent self.assertEqual(len(presence_sent), 1) self.assertEqual(presence_sent[0].get_to(), "user1@test.com") self.assertEqual(presence_sent[0].get_from(), "jcl.test.com") self.assertEqual(\ - presence_sent[0].xpath_eval("@type")[0].get_content(), \ + presence_sent[0].xpath_eval("@type")[0].get_content(), "subscribed") def test_handle_presence_subscribe_to_component_unknown_user(self): 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") model.db_disconnect() @@ -2108,39 +2136,41 @@ class JCLComponent_TestCase(JCLTestCase): self.comp.stream = MockStream() self.comp.stream_class = MockStream model.db_connect() - account11 = Account(user_jid = "user1@test.com", \ - name = "account11", \ - jid = "account11@jcl.test.com") - account12 = Account(user_jid = "user1@test.com", \ - name = "account12", \ - jid = "account12@jcl.test.com") - account2 = Account(user_jid = "user2@test.com", \ - name = "account2", \ - jid = "account2@jcl.test.com") + 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") + account2 = Account(user=User(jid="user2@test.com"), + name="account2", + jid="account2@jcl.test.com") model.db_disconnect() self.comp.handle_presence_subscribe(Presence(\ - stanza_type = "subscribe", \ - from_jid = "user1@test.com",\ - to_jid = "account11@jcl.test.com")) + stanza_type="subscribe", + from_jid="user1@test.com", + to_jid="account11@jcl.test.com")) presence_sent = self.comp.stream.sent self.assertEqual(len(presence_sent), 1) self.assertEqual(presence_sent[0].get_to(), "user1@test.com") self.assertEqual(presence_sent[0].get_from(), "account11@jcl.test.com") self.assertEqual(\ - presence_sent[0].xpath_eval("@type")[0].get_content(), \ + presence_sent[0].xpath_eval("@type")[0].get_content(), "subscribed") def test_handle_presence_subscribe_to_account_unknown_user(self): 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") model.db_disconnect() @@ -2155,20 +2185,21 @@ class JCLComponent_TestCase(JCLTestCase): self.comp.stream = MockStream() self.comp.stream_class = MockStream model.db_connect() - account11 = Account(user_jid = "user1@test.com", \ - name = "account11", \ - jid = "account11@jcl.test.com") - account12 = Account(user_jid = "user1@test.com", \ - name = "account12", \ - jid = "account12@jcl.test.com") - account2 = Account(user_jid = "user2@test.com", \ - name = "account2", \ - jid = "account2@jcl.test.com") + 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") + account2 = Account(user=User(jid="user2@test.com"), + name="account2", + jid="account2@jcl.test.com") model.db_disconnect() self.comp.handle_presence_subscribe(Presence(\ - stanza_type = "subscribe", \ - from_jid = "user1@test.com",\ - to_jid = "unknown@jcl.test.com")) + stanza_type="subscribe", + from_jid="user1@test.com", + to_jid="unknown@jcl.test.com")) presence_sent = self.comp.stream.sent self.assertEqual(len(presence_sent), 0) @@ -2177,20 +2208,21 @@ class JCLComponent_TestCase(JCLTestCase): self.comp.stream_class = MockStream self.comp.presence_subscribe_handlers += [(DefaultSubscribeHandler(self.comp),)] model.db_connect() - account11 = Account(user_jid = "user1@test.com", \ - name = "account11", \ - jid = "account11@jcl.test.com") - account12 = Account(user_jid = "user1@test.com", \ - name = "account12", \ - jid = "account12@jcl.test.com") - account2 = Account(user_jid = "user2@test.com", \ - name = "account2", \ - jid = "account2@jcl.test.com") + 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") + account2 = Account(user=User(jid="user2@test.com"), + name="account2", + jid="account2@jcl.test.com") model.db_disconnect() result = self.comp.handle_presence_subscribe(Presence(\ - stanza_type = "subscribe", \ - from_jid = "user1@test.com",\ - to_jid = "user1%test.com@jcl.test.com")) + stanza_type="subscribe", + from_jid="user1@test.com", + to_jid="user1%test.com@jcl.test.com")) sent = self.comp.stream.sent self.assertEqual(len(sent), 2) self.assertTrue(type(sent[0]), Presence) @@ -2208,13 +2240,14 @@ class JCLComponent_TestCase(JCLTestCase): 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") model.db_disconnect() @@ -2248,13 +2281,14 @@ class JCLComponent_TestCase(JCLTestCase): self.comp.stream_class = MockStream self.comp.presence_unsubscribe_handlers += [(DefaultUnsubscribeHandler(self.comp),)] 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") model.db_disconnect() @@ -2279,13 +2313,14 @@ class JCLComponent_TestCase(JCLTestCase): 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") model.db_disconnect() @@ -2304,13 +2339,14 @@ class JCLComponent_TestCase(JCLTestCase): 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") model.db_disconnect() @@ -2360,22 +2396,23 @@ class JCLComponent_TestCase(JCLTestCase): self.comp.stream_class = MockStream self.comp.authenticated() model.db_connect() - account11 = Account(user_jid = "user1@test.com", \ - name = "account11", \ - jid = "account11@jcl.test.com") + user1 = User(jid="user1@test.com") + account11 = Account(user=user1, + name="account11", + jid="account11@jcl.test.com") account11.waiting_password_reply = True - account12 = Account(user_jid = "user1@test.com", \ - name = "account12", \ - jid = "account12@jcl.test.com") - account2 = Account(user_jid = "user2@test.com", \ - name = "account2", \ - jid = "account2@jcl.test.com") + account12 = Account(user=user1, + name="account12", + jid="account12@jcl.test.com") + account2 = Account(user=User(jid="user2@test.com"), + name="account2", + jid="account2@jcl.test.com") model.db_disconnect() self.comp.handle_message(Message(\ - from_jid = "user1@test.com", \ - to_jid = "account11@jcl.test.com", \ - subject = "[PASSWORD]", \ - body = "secret")) + from_jid="user1@test.com", + to_jid="account11@jcl.test.com", + subject="[PASSWORD]", + body="secret")) messages_sent = self.comp.stream.sent self.assertEqual(len(messages_sent), 0) @@ -2384,22 +2421,23 @@ class JCLComponent_TestCase(JCLTestCase): self.comp.stream_class = MockStream self.comp.authenticated() model.db_connect() - account11 = ExampleAccount(user_jid = "user1@test.com", \ - name = "account11", \ - jid = "account11@jcl.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", \ - name = "account12", \ - jid = "account12@jcl.test.com") - account2 = ExampleAccount(user_jid = "user2@test.com", \ - name = "account2", \ - jid = "account2@jcl.test.com") + account12 = ExampleAccount(user=user1, + name="account12", + jid="account12@jcl.test.com") + account2 = ExampleAccount(user=User(jid="user2@test.com"), + name="account2", + jid="account2@jcl.test.com") model.db_disconnect() self.comp.handle_message(Message(\ - from_jid = "user1@test.com", \ - to_jid = "account11@jcl.test.com", \ - subject = "[PASSWORD]", \ - body = "secret")) + from_jid="user1@test.com", + to_jid="account11@jcl.test.com", + subject="[PASSWORD]", + body="secret")) messages_sent = self.comp.stream.sent self.assertEqual(len(messages_sent), 1) self.assertEqual(messages_sent[0].get_to(), "user1@test.com") @@ -2418,14 +2456,14 @@ class JCLComponent_TestCase(JCLTestCase): self.comp.stream = MockStream() self.comp.stream_class = MockStream model.db_connect() - _account = Account(user_jid = "user1@test.com", \ - name = "account11", \ - jid = "account11@jcl.test.com") + _account = Account(user=User(jid="user1@test.com"), + name="account11", + jid="account11@jcl.test.com") exception = Exception("test exception") self.comp.send_error(_account, exception) self.assertEqual(len(self.comp.stream.sent), 1) error_sent = self.comp.stream.sent[0] - self.assertEqual(error_sent.get_to(), _account.user_jid) + self.assertEqual(error_sent.get_to(), _account.user.jid) self.assertEqual(error_sent.get_from(), _account.jid) self.assertEqual(error_sent.get_type(), "error") self.assertEqual(error_sent.get_subject(), _account.default_lang_class.error_subject) @@ -2437,9 +2475,9 @@ class JCLComponent_TestCase(JCLTestCase): self.comp.stream = MockStream() self.comp.stream_class = MockStream model.db_connect() - _account = Account(user_jid = "user1@test.com", \ - name = "account11", \ - jid = "account11@jcl.test.com") + _account = Account(user=User(jid="user1@test.com"), + name="account11", + jid="account11@jcl.test.com") _account.in_error = True exception = Exception("test exception") self.comp.send_error(_account, exception) @@ -2469,13 +2507,14 @@ class JCLComponent_TestCase(JCLTestCase): self.comp.stream = MockStream() self.comp.stream_class = MockStream 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 = Example2Account(user_jid="user1@test.com", + account12 = Example2Account(user=user1, name="account12", jid="account12@jcl.test.com") - account2 = ExampleAccount(user_jid="user2@test.com", + account2 = ExampleAccount(user=User(jid="user2@test.com"), name="account2", jid="account2@jcl.test.com") model.db_disconnect() @@ -2502,14 +2541,15 @@ class JCLComponent_TestCase(JCLTestCase): class Handler_TestCase(JCLTestCase): def setUp(self): self.handler = Handler(None) - JCLTestCase.setUp(self, tables=[Account]) + JCLTestCase.setUp(self, tables=[Account, User]) def test_filter(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") accounts = self.handler.filter(None, None) @@ -2522,12 +2562,58 @@ class Handler_TestCase(JCLTestCase): def test_handle(self): self.assertEquals(self.handler.handle(None, None, None), []) +class AccountManager_TestCase(JCLTestCase): + def setUp(self): + JCLTestCase.setUp(self, tables=[User, Account, LegacyJID]) + self.comp = JCLComponent("jcl.test.com", + "password", + "localhost", + "5347", + None) + self.account_manager = AccountManager(self.comp) + + def test_send_presence_all(self): + user1 = User(jid="test1@test.com") + account11 = Account(user=user1, + name="account11", + jid="account11@jcl.test.com") + account12 = Account(user=user1, + name="account12", + jid="account12@jcl.test.com") + user2 = User(jid="test2@test.com") + account21 = Account(user=user2, + name="account21", + jid="account21@jcl.test.com") + account22 = Account(user=user2, + name="account22", + jid="account22@jcl.test.com") + result = self.account_manager.send_presence_all("unavailable") + self.assertEquals(len(result), 6) + self.assertEquals(result[0].get_from(), "jcl.test.com") + self.assertEquals(result[0].get_to(), "test1@test.com") + self.assertEquals(result[0].get_type(), "unavailable") + self.assertEquals(result[1].get_from(), "jcl.test.com") + self.assertEquals(result[1].get_to(), "test2@test.com") + self.assertEquals(result[1].get_type(), "unavailable") + self.assertEquals(result[2].get_from(), "account11@jcl.test.com") + self.assertEquals(result[2].get_to(), "test1@test.com") + self.assertEquals(result[2].get_type(), "unavailable") + self.assertEquals(result[3].get_from(), "account12@jcl.test.com") + self.assertEquals(result[3].get_to(), "test1@test.com") + self.assertEquals(result[3].get_type(), "unavailable") + self.assertEquals(result[4].get_from(), "account21@jcl.test.com") + self.assertEquals(result[4].get_to(), "test2@test.com") + self.assertEquals(result[4].get_type(), "unavailable") + self.assertEquals(result[5].get_from(), "account22@jcl.test.com") + self.assertEquals(result[5].get_to(), "test2@test.com") + self.assertEquals(result[5].get_type(), "unavailable") def suite(): - suite = unittest.TestSuite() - suite.addTest(unittest.makeSuite(JCLComponent_TestCase, 'test')) - suite.addTest(unittest.makeSuite(Handler_TestCase, 'test')) - return suite + test_suite = unittest.TestSuite() + test_suite.addTest(unittest.makeSuite(JCLComponent_TestCase, 'test')) + test_suite.addTest(unittest.makeSuite(Handler_TestCase, 'test')) + test_suite.addTest(unittest.makeSuite(AccountManager_TestCase, 'test')) + return test_suite if __name__ == '__main__': unittest.main(defaultTest='suite') diff --git a/src/jcl/jabber/tests/feeder.py b/src/jcl/jabber/tests/feeder.py index b3391b5..b698da8 100644 --- a/src/jcl/jabber/tests/feeder.py +++ b/src/jcl/jabber/tests/feeder.py @@ -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') diff --git a/src/jcl/jabber/tests/message.py b/src/jcl/jabber/tests/message.py index 8c6432b..adba08c 100644 --- a/src/jcl/jabber/tests/message.py +++ b/src/jcl/jabber/tests/message.py @@ -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') diff --git a/src/jcl/jabber/tests/presence.py b/src/jcl/jabber/tests/presence.py index 60fb835..5558de3 100644 --- a/src/jcl/jabber/tests/presence.py +++ b/src/jcl/jabber/tests/presence.py @@ -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') diff --git a/src/jcl/model/account.py b/src/jcl/model/account.py index 70757ee..ab896cd 100644 --- a/src/jcl/model/account.py +++ b/src/jcl/model/account.py @@ -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() diff --git a/src/jcl/model/tests/account.py b/src/jcl/model/tests/account.py index c54ad2e..431c373 100644 --- a/src/jcl/model/tests/account.py +++ b/src/jcl/model/tests/account.py @@ -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() diff --git a/src/jcl/runner.py b/src/jcl/runner.py index 3dabd31..c532304 100644 --- a/src/jcl/runner.py +++ b/src/jcl/runner.py @@ -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) diff --git a/src/jcl/tests/__init__.py b/src/jcl/tests/__init__.py index 43ab3df..e1105f4 100644 --- a/src/jcl/tests/__init__.py +++ b/src/jcl/tests/__init__.py @@ -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') diff --git a/src/jcl/tests/runner.py b/src/jcl/tests/runner.py index 45e263d..323798a 100644 --- a/src/jcl/tests/runner.py +++ b/src/jcl/tests/runner.py @@ -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')