diff --git a/run_tests.py b/run_tests.py index c9b2174..b558176 100644 --- a/run_tests.py +++ b/run_tests.py @@ -63,7 +63,7 @@ if __name__ == '__main__': jcl_suite = unittest.TestSuite() # jcl_suite.addTest(FeederComponent_TestCase('test_handle_tick')) # jcl_suite.addTest(JCLComponent_TestCase('test_handle_set_register_new_field_mandatory')) -# jcl_suite = unittest.TestSuite((feeder_component_suite)) +# jcl_suite = unittest.TestSuite((component_suite)) # jcl_suite = unittest.TestSuite((presence_account_suite)) jcl_suite = unittest.TestSuite((component_suite, \ feeder_component_suite, \ diff --git a/src/jcl/jabber/component.py b/src/jcl/jabber/component.py index 82ecae1..b362263 100644 --- a/src/jcl/jabber/component.py +++ b/src/jcl/jabber/component.py @@ -43,7 +43,7 @@ from sqlobject.dbconnection import connectionForURI import pyxmpp.error as error from pyxmpp.jid import JID from pyxmpp.jabberd.component import Component -from pyxmpp.jabber.disco import DiscoInfo, DiscoItems, DiscoItem +from pyxmpp.jabber.disco import DiscoInfo, DiscoItems, DiscoItem, DiscoIdentity from pyxmpp.message import Message from pyxmpp.presence import Presence @@ -88,15 +88,13 @@ class JCLComponent(Component, object): self.name = "Jabber Component Library generic component" self.spool_dir = "." self.db_connection_str = db_connection_str - self.default_account_class = Account + self.account_classes = [Account] self.account_factory = default_account_factory.create self.version = VERSION self.accounts = [] self.time_unit = 60 self.queue = Queue(100) - self.disco_info.add_feature("jabber:iq:version") - self.disco_info.add_feature("jabber:iq:register") self.__logger = logging.getLogger("jcl.jabber.JCLComponent") self.lang = Lang() self.running = False @@ -104,7 +102,7 @@ class JCLComponent(Component, object): signal.signal(signal.SIGINT, self.signal_handler) signal.signal(signal.SIGTERM, self.signal_handler) - + def run(self): """Main loop Connect to Jabber server @@ -139,7 +137,7 @@ class JCLComponent(Component, object): # Explicit reference to account table (clauseTables) to use # "user_jid" column with Account subclasses for _account in \ - self.default_account_class.select(clauseTables = ["account"], \ + self.account_classes[0].select(clauseTables = ["account"], \ orderBy = "user_jid"): if current_user_jid != _account.user_jid: current_user_jid = _account.user_jid @@ -229,7 +227,7 @@ class JCLComponent(Component, object): self.handle_message) current_jid = None self.db_connect() - for _account in self.default_account_class.select(clauseTables = ["account"], \ + for _account in self.account_classes[0].select(clauseTables = ["account"], \ orderBy = "user_jid"): if _account.user_jid != current_jid: presence = Presence(from_jid = unicode(self.jid), \ @@ -253,12 +251,17 @@ class JCLComponent(Component, object): """Discovery get info handler """ self.__logger.debug("DISCO_GET_INFO") + disco_info = DiscoInfo() if node is not None: - disco_info = DiscoInfo() disco_info.add_feature("jabber:iq:register") - return disco_info else: - return self.disco_info + disco_info.add_feature("jabber:iq:version") + if len(self.account_classes) == 1: + disco_info.add_feature("jabber:iq:register") + DiscoIdentity(disco_info, self.disco_identity.name, + self.disco_identity.category, + self.disco_identity.type) + return disco_info def disco_get_items(self, node, info_query): """Discovery get nested nodes handler @@ -267,14 +270,31 @@ class JCLComponent(Component, object): base_from_jid = unicode(info_query.get_from().bare()) disco_items = DiscoItems() if not node: - self.db_connect() - for _account in self.default_account_class.select(Account.q.user_jid == \ - base_from_jid): - self.__logger.debug(str(_account)) - DiscoItem(disco_items, \ - JID(_account.jid), \ - _account.name, _account.long_name) - self.db_disconnect() + if len(self.account_classes) == 1: + self._list_accounts(disco_items, self.account_classes[0], base_from_jid) + else: + for account_class in self.account_classes: + regexp_type = re.compile("(.*)Account$") + match = regexp_type.search(account_class.__name__) + if match is not None: + account_type = match.group(1) + DiscoItem(disco_items, \ + JID(account_type + "@" + unicode(self.jid)), \ + account_type, \ + account_type) + else: + nodes = node.split("/"); + if len(nodes) == 1 \ + and len(self.account_classes) > 1: + self.__logger.debug("Listing account for " + nodes[0]) # for p1 TODO add type to get_items + account_class = self._get_account_class(nodes[0] + "Account") + if account_class is not None: + self._list_accounts(disco_items, \ + account_class, \ + base_from_jid) + else: + print >> sys.stderr, "Error: " + account_class.__name__ \ + + " class not in account_classes" return disco_items def handle_get_version(self, info_query): @@ -300,12 +320,19 @@ class JCLComponent(Component, object): query = info_query.new_query("jabber:iq:register") if to_jid.node is not None: node_list = to_jid.node.split("/") - if (len(node_list) == 2): - _account_class = globals()[node_list[0] + "Account"] + name = None + if len(node_list) == 2: + _account_class = self._get_account_class(node_list[0] + "Account") name = node_list[1] else: - _account_class = self.default_account_class - name = node_list[0] + if len(node_list) == 1: + if len(self.account_classes) == 1: + _account_class = self.account_classes[0] + name = node_list[0] + else: + _account_class = self._get_account_class(node_list[0] + "Account") + self.get_reg_form(lang_class, \ + _account_class).attach_xml(query) self.db_connect() for _account in _account_class.select(\ AND(_account_class.q.name == name, \ @@ -315,7 +342,7 @@ class JCLComponent(Component, object): self.db_disconnect() else: self.get_reg_form(lang_class, \ - self.default_account_class).attach_xml(query) + self.account_classes[0]).attach_xml(query) self.stream.send(info_query) return 1 @@ -323,8 +350,8 @@ class JCLComponent(Component, object): """Unsubscribe all accounts associated to 'user_jid' then delete those accounts from the DataBase""" self.db_connect() - for _account in self.default_account_class.select(\ - self.default_account_class.q.user_jid == user_jid): + for _account in self.account_classes[0].select(\ + self.account_classes[0].q.user_jid == user_jid): self.__logger.debug("Deleting " + _account.name \ + " for " + user_jid) presence = Presence(from_jid = self.get_jid(_account), \ @@ -343,7 +370,7 @@ class JCLComponent(Component, object): stanza_type = "unsubscribed") self.stream.send(presence) self.db_disconnect() - + def handle_set_register(self, info_query): """Handle user registration response """ @@ -374,14 +401,14 @@ class JCLComponent(Component, object): lang_class.mandatory_field % ("name")) text.setNs(text.newNs(error.STANZA_ERROR_NS, None)) self.stream.send(iq_error) - return + return self.db_connect() - accounts = self.default_account_class.select(\ - AND(self.default_account_class.q.name == name, \ - self.default_account_class.q.user_jid == base_from_jid)) + accounts = Account.select(\ + AND(Account.q.name == name, \ + Account.q.user_jid == base_from_jid)) accounts_count = accounts.count() - all_accounts = self.default_account_class.select(\ - self.default_account_class.q.user_jid == base_from_jid) + all_accounts = Account.select(\ + Account.q.user_jid == base_from_jid) all_accounts_count = all_accounts.count() if accounts_count > 1: # Just print a warning, only the first account will be use @@ -390,21 +417,27 @@ class JCLComponent(Component, object): if accounts_count >= 1: _account = list(accounts)[0] else: - _account = self.account_factory(\ - user_jid = base_from_jid, \ - name = name, \ - jid = name + u"@" + unicode(self.jid), \ - x_data = x_data) + if info_query.get_to().node is None: + if len(self.account_classes) > 1: + print >>sys.stderr, "There should be only one account class declared" + new_account_class = self.account_classes[0] + else: + new_account_class = self._get_account_class(info_query.get_to().node + "Account") + _account = new_account_class(user_jid = unicode(base_from_jid), \ + name = name, \ + jid = name + u"@" + unicode(self.jid)) field = None try: for (field, field_type, field_options, field_post_func, \ field_default_func) in _account.get_register_fields(): - setattr(_account, field, \ - x_data.get_field_value(field, \ - field_post_func, \ - field_default_func)) + if field is not None: + setattr(_account, field, \ + x_data.get_field_value(field, \ + field_post_func, \ + field_default_func)) except FieldError, exception: _account.destroySelf() + print >>sys.stderr, str(exception) iq_error = info_query.make_error_response("not-acceptable") text = iq_error.get_error().xmlnode.newTextChild(None, \ "text", \ @@ -441,7 +474,7 @@ class JCLComponent(Component, object): """Handle presence availability if presence sent to the component ('if not name'), presence is sent to all accounts for current user. Otherwise, send presence from current account. - + """ self.__logger.debug("PRESENCE_AVAILABLE") from_jid = stanza.get_from() @@ -454,8 +487,8 @@ class JCLComponent(Component, object): self.__logger.debug("TO : " + name + " " + base_from_jid) self.db_connect() if not name: - accounts = self.default_account_class.select(\ - self.default_account_class.q.user_jid == base_from_jid) + accounts = self.account_classes[0].select(\ + self.account_classes[0].q.user_jid == base_from_jid) accounts_length = 0 for _account in accounts: accounts_length += 1 @@ -470,9 +503,9 @@ class JCLComponent(Component, object): stanza_type = "available") self.stream.send(presence) else: - accounts = self.default_account_class.select(\ - AND(self.default_account_class.q.name == name, \ - self.default_account_class.q.user_jid == base_from_jid)) + accounts = self.account_classes[0].select(\ + AND(self.account_classes[0].q.name == name, \ + self.account_classes[0].q.user_jid == base_from_jid)) if accounts.count() > 0: self._send_presence_available(accounts[0], show, lang_class) self.db_disconnect() @@ -487,8 +520,8 @@ class JCLComponent(Component, object): name = stanza.get_to().node self.db_connect() if not name: - accounts = self.default_account_class.select(\ - self.default_account_class.q.user_jid == base_from_jid) + accounts = self.account_classes[0].select(\ + self.account_classes[0].q.user_jid == base_from_jid) for _account in accounts: _account.status = jcl.model.account.OFFLINE presence = Presence(from_jid = _account.jid, \ @@ -501,14 +534,14 @@ class JCLComponent(Component, object): stanza_type = "unavailable") self.stream.send(presence) else: - accounts = self.default_account_class.select(\ - AND(self.default_account_class.q.name == name, \ - self.default_account_class.q.user_jid == base_from_jid)) + accounts = self.account_classes[0].select(\ + AND(self.account_classes[0].q.name == name, \ + self.account_classes[0].q.user_jid == base_from_jid)) if accounts.count() > 0: presence = Presence(from_jid = stanza.get_to(), \ to_jid = from_jid, \ stanza_type = "unavailable") - self.stream.send(presence) + self.stream.send(presence) self.db_disconnect() return 1 @@ -522,12 +555,12 @@ class JCLComponent(Component, object): accounts = None self.db_connect() if not name: - accounts = self.default_account_class.select(\ - self.default_account_class.q.user_jid == base_from_jid) + accounts = self.account_classes[0].select(\ + self.account_classes[0].q.user_jid == base_from_jid) else: - accounts = self.default_account_class.select(\ - AND(self.default_account_class.q.name == name, \ - self.default_account_class.q.user_jid == base_from_jid)) + accounts = self.account_classes[0].select(\ + AND(self.account_classes[0].q.name == name, \ + self.account_classes[0].q.user_jid == base_from_jid)) if (accounts is not None \ and accounts.count() > 0): presence = stanza.make_accept_response() @@ -549,9 +582,9 @@ class JCLComponent(Component, object): from_jid = stanza.get_from() base_from_jid = unicode(from_jid.bare()) self.db_connect() - accounts = self.default_account_class.select(\ - AND(self.default_account_class.q.name == name, \ - self.default_account_class.q.user_jid == base_from_jid)) + accounts = self.account_classes[0].select(\ + AND(self.account_classes[0].q.name == name, \ + self.account_classes[0].q.user_jid == base_from_jid)) for _account in accounts: presence = Presence(from_jid = _account.jid, \ to_jid = from_jid, \ @@ -584,9 +617,9 @@ class JCLComponent(Component, object): name = message.get_to().node base_from_jid = unicode(message.get_from().bare()) self.db_connect() - accounts = self.default_account_class.select(\ - AND(self.default_account_class.q.name == name, \ - self.default_account_class.q.user_jid == base_from_jid)) + accounts = self.account_classes[0].select(\ + AND(self.account_classes[0].q.name == name, \ + self.account_classes[0].q.user_jid == base_from_jid)) if accounts.count() == 1: _account = list(accounts)[0] if hasattr(_account, 'password') \ @@ -607,6 +640,27 @@ class JCLComponent(Component, object): ########################################################################### # Utils ########################################################################### + def _get_account_class(self, account_class_name): + """Return account class definition from declared classes in + account_classes from its class name""" + self.__logger.debug("Looking for " + account_class_name) + for _account_class in self.account_classes: + if _account_class.__name__.lower() == account_class_name.lower(): + self.__logger.debug(account_class_name + " found") + return _account_class + return None + + def _list_accounts(self, disco_items, _account_class, base_from_jid): + """List accounts in disco_items for given _account_class and user jid""" + self.db_connect() + for _account in _account_class.select(_account_class.q.user_jid == \ + base_from_jid): + self.__logger.debug(str(_account)) + DiscoItem(disco_items, \ + JID(_account.jid), \ + _account.name, _account.long_name) + self.db_disconnect() + def _send_presence_available(self, _account, show, lang_class): """Send available presence to account's user and ask for password if necessary""" diff --git a/src/jcl/jabber/feeder.py b/src/jcl/jabber/feeder.py index 9e8f26c..f7c205a 100644 --- a/src/jcl/jabber/feeder.py +++ b/src/jcl/jabber/feeder.py @@ -58,8 +58,8 @@ class FeederComponent(JCLComponent): def handle_tick(self): """Implement main feed/send behavior""" self.db_connect() - for _account in self.default_account_class.select(clauseTables = ["account"], \ - orderBy = "user_jid"): + for _account in self.account_classes[0].select(clauseTables = ["account"], \ + orderBy = "user_jid"): for data in self.feeder.feed(_account): self.sender.send(_account, data) self.db_disconnect() diff --git a/src/jcl/lang.py b/src/jcl/lang.py index 2346e64..eb4e86b 100644 --- a/src/jcl/lang.py +++ b/src/jcl/lang.py @@ -79,6 +79,9 @@ class Lang: new_account_message_subject = u"New account '%s' created" new_account_message_body = u"New account created" mandatory_field = u"%s is required" + + presence_action_0 = u"Do nothing" + presence_chat_action_0 = presence_action_0 # account_login = u"Login" # account_password = u"Password" diff --git a/src/jcl/model/account.py b/src/jcl/model/account.py index 4f4b756..4523406 100644 --- a/src/jcl/model/account.py +++ b/src/jcl/model/account.py @@ -188,8 +188,8 @@ class PresenceAccount(Account): def _get_register_fields(cls): """ See Account._get_register_fields """ def is_action_possible(action): - if action in cls.possibles_actions: - return action + if int(action) in cls.possibles_actions: + return int(action) raise FieldError # TODO : add translated message # TODO : check is_action_possible with presence_actions_fields (see partial eval function) diff --git a/tests/jcl/jabber/test_component.py b/tests/jcl/jabber/test_component.py index af21b79..617b6bd 100644 --- a/tests/jcl/jabber/test_component.py +++ b/tests/jcl/jabber/test_component.py @@ -316,10 +316,13 @@ class JCLComponent_TestCase(unittest.TestCase): def test_disco_get_info_node(self): disco_info = self.comp.disco_get_info("node_test", None) - self.assertFalse(disco_info.has_feature("jabber:iq:version")) self.assertTrue(disco_info.has_feature("jabber:iq:register")) - def test_disco_get_items_no_node(self): + def test_disco_get_info_long_node(self): + disco_info = self.comp.disco_get_info("node_type/node_test", None) + self.assertTrue(disco_info.has_feature("jabber:iq:register")) + + def test_disco_get_items_1type_no_node(self): account.hub.threadConnection = connectionForURI('sqlite://' + DB_URL) account1 = Account(user_jid = "user1@test.com", \ name = "account1", \ @@ -334,7 +337,7 @@ class JCLComponent_TestCase(unittest.TestCase): self.assertEquals(disco_item.get_node(), account1.name) self.assertEquals(disco_item.get_name(), account1.long_name) - def test_disco_get_items_with_node(self): + def test_disco_get_items_1type_with_node(self): account.hub.threadConnection = connectionForURI('sqlite://' + DB_URL) account1 = Account(user_jid = "user1@test.com", \ name = "account1", \ @@ -345,6 +348,58 @@ class JCLComponent_TestCase(unittest.TestCase): disco_items = self.comp.disco_get_items("account1", info_query) self.assertEquals(disco_items.get_items(), []) + # TODO : test get_items with multiple account_classes + def test_disco_get_items_2types_no_node(self): + account.hub.threadConnection = connectionForURI('sqlite://' + DB_URL) + account1 = Account(user_jid = "user1@test.com", \ + name = "account1", \ + jid = "account1@jcl.test.com") + del account.hub.threadConnection + info_query = Iq(stanza_type = "get", \ + from_jid = "user1@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] + self.assertEquals(disco_item.get_jid(), account1.jid) + self.assertEquals(disco_item.get_node(), account1.name) + self.assertEquals(disco_item.get_name(), account1.long_name) + + # TODO + def test_disco_get_items_2types_with_node(self): + account.hub.threadConnection = connectionForURI('sqlite://' + DB_URL) + account1 = Account(user_jid = "user1@test.com", \ + name = "account1", \ + jid = "account1@jcl.test.com") + del account.hub.threadConnection + info_query = Iq(stanza_type = "get", \ + from_jid = "user1@test.com") + disco_items = self.comp.disco_get_items("account1", info_query) + self.assertEquals(disco_items.get_items(), []) + + # TODO + def test_disco_get_items_2types_with_long_node(self): + account.hub.threadConnection = connectionForURI('sqlite://' + DB_URL) + account1 = Account(user_jid = "user1@test.com", \ + name = "account1", \ + jid = "account1@jcl.test.com") + del account.hub.threadConnection + info_query = Iq(stanza_type = "get", \ + from_jid = "user1@test.com") + disco_items = self.comp.disco_get_items("type1/account1", info_query) + self.assertEquals(disco_items.get_items(), []) + + # TODO + def test_disco_get_items_2types_with_long_node2(self): + account.hub.threadConnection = connectionForURI('sqlite://' + DB_URL) + account1 = Account(user_jid = "user1@test.com", \ + name = "account1", \ + jid = "account1@jcl.test.com") + del account.hub.threadConnection + info_query = Iq(stanza_type = "get", \ + from_jid = "user1@test.com") + disco_items = self.comp.disco_get_items("type2/account1", info_query) + self.assertEquals(disco_items.get_items(), []) + def test_handle_get_version(self): self.comp.stream = MockStream() self.comp.stream_class = MockStream @@ -396,7 +451,7 @@ class JCLComponent_TestCase(unittest.TestCase): def test_handle_get_register_new_complex(self): self.comp.stream = MockStream() self.comp.stream_class = MockStream - self.comp.default_account_class = AccountExample + self.comp.account_classes = [AccountExample] self.comp.handle_get_register(Iq(stanza_type = "get", \ from_jid = "user1@test.com", \ to_jid = "jcl.test.com")) @@ -627,9 +682,9 @@ class JCLComponent_TestCase(unittest.TestCase): self.comp.handle_set_register(iq_set) account.hub.threadConnection = connectionForURI('sqlite://' + DB_URL) - accounts = self.comp.default_account_class.select(\ - self.comp.default_account_class.q.user_jid == "user1@test.com" \ - and self.comp.default_account_class.q.name == "account1") + accounts = self.comp.account_classes[0].select(\ + self.comp.account_classes[0].q.user_jid == "user1@test.com" \ + and self.comp.account_classes[0].q.name == "account1") self.assertEquals(accounts.count(), 1) _account = accounts[0] self.assertEquals(_account.user_jid, "user1@test.com") @@ -671,10 +726,7 @@ class JCLComponent_TestCase(unittest.TestCase): def test_handle_set_register_new_complex(self): self.comp.stream = MockStream() self.comp.stream_class = MockStream - self.comp.account_factory = (lambda user_jid, name, jid, x_data: \ - AccountExample(user_jid = user_jid, \ - name = name, \ - jid = jid)) + self.comp.account_classes = [AccountExample] x_data = DataForm() x_data.xmlns = "jabber:x:data" x_data.type = "submit" @@ -704,9 +756,9 @@ class JCLComponent_TestCase(unittest.TestCase): self.comp.handle_set_register(iq_set) account.hub.threadConnection = connectionForURI('sqlite://' + DB_URL) - accounts = self.comp.default_account_class.select(\ - self.comp.default_account_class.q.user_jid == "user1@test.com" \ - and self.comp.default_account_class.q.name == "account1") + accounts = self.comp.account_classes[0].select(\ + self.comp.account_classes[0].q.user_jid == "user1@test.com" \ + and self.comp.account_classes[0].q.name == "account1") self.assertEquals(accounts.count(), 1) _account = accounts[0] self.assertEquals(_account.user_jid, "user1@test.com") @@ -753,10 +805,7 @@ class JCLComponent_TestCase(unittest.TestCase): def test_handle_set_register_new_default_values(self): self.comp.stream = MockStream() self.comp.stream_class = MockStream - self.comp.account_factory = (lambda user_jid, name, jid, x_data: \ - AccountExample(user_jid = user_jid, \ - name = name, \ - jid = jid)) + self.comp.account_classes = [AccountExample] x_data = DataForm() x_data.xmlns = "jabber:x:data" x_data.type = "submit" @@ -774,9 +823,9 @@ class JCLComponent_TestCase(unittest.TestCase): self.comp.handle_set_register(iq_set) account.hub.threadConnection = connectionForURI('sqlite://' + DB_URL) - accounts = self.comp.default_account_class.select(\ - self.comp.default_account_class.q.user_jid == "user1@test.com" \ - and self.comp.default_account_class.q.name == "account1") + accounts = self.comp.account_classes[0].select(\ + self.comp.account_classes[0].q.user_jid == "user1@test.com" \ + and self.comp.account_classes[0].q.name == "account1") self.assertEquals(accounts.count(), 1) _account = accounts[0] self.assertEquals(_account.user_jid, "user1@test.com") @@ -803,9 +852,9 @@ class JCLComponent_TestCase(unittest.TestCase): self.comp.handle_set_register(iq_set) account.hub.threadConnection = connectionForURI('sqlite://' + DB_URL) - accounts = self.comp.default_account_class.select(\ - self.comp.default_account_class.q.user_jid == "user1@test.com" \ - and self.comp.default_account_class.q.name == "account1") + accounts = self.comp.account_classes[0].select(\ + self.comp.account_classes[0].q.user_jid == "user1@test.com" \ + and self.comp.account_classes[0].q.name == "account1") self.assertEquals(accounts.count(), 0) del account.hub.threadConnection @@ -822,10 +871,7 @@ class JCLComponent_TestCase(unittest.TestCase): def test_handle_set_register_new_field_mandatory(self): self.comp.stream = MockStream() self.comp.stream_class = MockStream - self.comp.account_factory = (lambda user_jid, name, jid, x_data: \ - AccountExample(user_jid = user_jid, \ - name = name, \ - jid = jid)) + self.comp.account_classes = [AccountExample] x_data = DataForm() x_data.xmlns = "jabber:x:data" x_data.type = "submit" @@ -840,9 +886,9 @@ class JCLComponent_TestCase(unittest.TestCase): self.comp.handle_set_register(iq_set) account.hub.threadConnection = connectionForURI('sqlite://' + DB_URL) - accounts = self.comp.default_account_class.select(\ - self.comp.default_account_class.q.user_jid == "user1@test.com" \ - and self.comp.default_account_class.q.name == "account1") + accounts = self.comp.account_classes[0].select(\ + self.comp.account_classes[0].q.user_jid == "user1@test.com" \ + and self.comp.account_classes[0].q.name == "account1") self.assertEquals(accounts.count(), 0) del account.hub.threadConnection @@ -906,9 +952,9 @@ class JCLComponent_TestCase(unittest.TestCase): self.comp.handle_set_register(iq_set) account.hub.threadConnection = connectionForURI('sqlite://' + DB_URL) - accounts = self.comp.default_account_class.select(\ - self.comp.default_account_class.q.user_jid == "user1@test.com" \ - and self.comp.default_account_class.q.name == "account1") + accounts = self.comp.account_classes[0].select(\ + self.comp.account_classes[0].q.user_jid == "user1@test.com" \ + and self.comp.account_classes[0].q.name == "account1") self.assertEquals(accounts.count(), 1) _account = accounts[0] self.assertEquals(_account.user_jid, "user1@test.com") @@ -960,11 +1006,11 @@ class JCLComponent_TestCase(unittest.TestCase): self.comp.handle_set_register(iq_set) account.hub.threadConnection = connectionForURI('sqlite://' + DB_URL) - accounts = self.comp.default_account_class.select(\ - self.comp.default_account_class.q.user_jid == "user1@test.com") + accounts = self.comp.account_classes[0].select(\ + self.comp.account_classes[0].q.user_jid == "user1@test.com") self.assertEquals(accounts.count(), 0) - accounts = self.comp.default_account_class.select(\ - self.comp.default_account_class.q.user_jid == "user2@test.com") + accounts = self.comp.account_classes[0].select(\ + self.comp.account_classes[0].q.user_jid == "user2@test.com") self.assertEquals(accounts.count(), 1) _account = accounts[0] self.assertEquals(_account.user_jid, "user2@test.com") @@ -1495,14 +1541,14 @@ class JCLComponent_TestCase(unittest.TestCase): self.assertEqual(presence.xpath_eval("@type")[0].get_content(), \ "unsubscribed") account.hub.threadConnection = connectionForURI('sqlite://' + DB_URL) - self.assertEquals(self.comp.default_account_class.select(\ - self.comp.default_account_class.q.user_jid == "user1@test.com" \ - and self.comp.default_account_class.q.name == "account11").count(), \ + self.assertEquals(self.comp.account_classes[0].select(\ + self.comp.account_classes[0].q.user_jid == "user1@test.com" \ + and self.comp.account_classes[0].q.name == "account11").count(), \ 0) - self.assertEquals(self.comp.default_account_class.select(\ - self.comp.default_account_class.q.user_jid == "user1@test.com").count(), \ + self.assertEquals(self.comp.account_classes[0].select(\ + self.comp.account_classes[0].q.user_jid == "user1@test.com").count(), \ 1) - self.assertEquals(self.comp.default_account_class.select().count(), \ + self.assertEquals(self.comp.account_classes[0].select().count(), \ 2) del account.hub.threadConnection @@ -1527,7 +1573,7 @@ class JCLComponent_TestCase(unittest.TestCase): presence_sent = self.comp.stream.sent self.assertEqual(len(presence_sent), 0) account.hub.threadConnection = connectionForURI('sqlite://' + DB_URL) - self.assertEquals(self.comp.default_account_class.select().count(), \ + self.assertEquals(self.comp.account_classes[0].select().count(), \ 3) del account.hub.threadConnection @@ -1553,7 +1599,7 @@ class JCLComponent_TestCase(unittest.TestCase): presence_sent = self.comp.stream.sent self.assertEqual(len(presence_sent), 0) account.hub.threadConnection = connectionForURI('sqlite://' + DB_URL) - self.assertEquals(self.comp.default_account_class.select().count(), \ + self.assertEquals(self.comp.account_classes[0].select().count(), \ 3) del account.hub.threadConnection