Filter returned accounts in ad-hoc commands

darcs-hash:20070807162415-86b55-cfd614bfbbeef6695418eefc25bf3067bd414f64.gz

src/jcl/jabber/command.py

@@ -31,6 +31,7 @@ from pyxmpp.jabber.dataforms import Form, Field
 
 from jcl.jabber.disco import DiscoHandler, RootDiscoGetInfoHandler
 from jcl.model import account
+from jcl.model.account import Account
 
 COMMAND_NS = "http://jabber.org/protocol/commands"
 
@@ -177,10 +178,7 @@ class CommandManager(object):
                         {"c": "http://jabber.org/protocol/commands",
                          "data": "jabber:x:data"})
             if len(values) > 0:
-                if len(values) > 1:
                 values = map(lambda value: value.content, values)
-                else:
-                    values = values[0].content
                 self.__logger.debug("Adding to session '" + session_id
                                     + "': " + field_name + "="
                                     + str(values))
@@ -284,19 +282,23 @@ class JCLCommandManager(CommandManager):
         result_form.as_xml(command_node)
         return result_form
 
-    def __add_accounts_to_field(self, user_jids, field, lang_class):
+    def __add_accounts_to_field(self, user_jids, field, lang_class, filter=None):
         for (account_type, type_label) in \
                 self.account_manager.list_account_types(lang_class):
             account_class = self.account_manager.get_account_class(\
                 account_type=account_type)
             for user_jid in user_jids:
-                for _account in account.get_accounts(user_jid, account_class):
+                self.__logger.debug("Listing " + str(user_jid) + "'s accounts")
+                for _account in account.get_accounts(user_jid, account_class,
+                                                     filter):
+                    self.__logger.debug(" - " + _account.name)
                     field.add_option(label=_account.name + " (" + account_type
                                      + ") (" + user_jid + ")",
                                      values=[_account.name + "/" + user_jid])
 
     def add_form_select_accounts(self, session_context,
-                                 command_node, lang_class):
+                                 command_node, lang_class,
+                                 filter=None):
         """
         Add a form to select accounts for user JIDs contained in
         session_context[\"user_jids\"]
@@ -307,7 +309,7 @@ class JCLCommandManager(CommandManager):
                                       field_type="list-multi",
                                       label="Account") # TODO
         self.__add_accounts_to_field(session_context["user_jids"],
-                                     field, lang_class)
+                                     field, lang_class, filter)
         result_form.as_xml(command_node)
         return result_form
 
@@ -322,7 +324,7 @@ class JCLCommandManager(CommandManager):
         field = result_form.add_field(name="account_name",
                                       field_type="list-single",
                                       label="Account") # TODO
-        self.__add_accounts_to_field([session_context["user_jid"]],
+        self.__add_accounts_to_field(session_context["user_jid"],
                                      field, lang_class)
         result_form.as_xml(command_node)
         return result_form
@@ -397,8 +399,8 @@ class JCLCommandManager(CommandManager):
                            command_node, lang_class):
         self.__logger.debug("Executing command 'add-user' step 2")
         self.add_actions(command_node, [ACTION_PREVIOUS, ACTION_COMPLETE], 1)
-        user_jid = session_context["user_jid"]
+        user_jid = session_context["user_jid"][0]
-        account_type = session_context["account_type"]
+        account_type = session_context["account_type"][0]
         account_class = self.account_manager.get_account_class(account_type)
         result_form = self.account_manager.generate_registration_form(lang_class,
                                                                       account_class,
@@ -414,9 +416,9 @@ class JCLCommandManager(CommandManager):
                                         "jxd" : "jabber:x:data"})[0]
         x_data = Form(x_node)
         to_send = self.component.account_manager.create_account_from_type(\
-            account_name=session_context["name"],
+            account_name=session_context["name"][0],
-            from_jid=JID(session_context["user_jid"]),
+            from_jid=JID(session_context["user_jid"][0]),
-            account_type=session_context["account_type"],
+            account_type=session_context["account_type"][0],
             lang_class=lang_class,
             x_data=x_data)
         command_node.setProp("status", STATUS_COMPLETED)
@@ -437,7 +439,15 @@ class JCLCommandManager(CommandManager):
         return (None, result)
 
     execute_disable_user_1 = select_user_jids_step_1
-    execute_disable_user_2 = select_accounts_step_2
+    
+    def execute_disable_user_2(self, info_query, session_context,
+                               command_node, lang_class):
+        self.__logger.debug("Executing 'disable-user' step 2")
+        self.add_actions(command_node, [ACTION_PREVIOUS, ACTION_COMPLETE], 1)
+        return (self.add_form_select_accounts(session_context, command_node,
+                                              lang_class,
+                                              Account.q.enabled==True),
+                [])
 
     def execute_disable_user_3(self, info_query, session_context,
                                command_node, lang_class):
@@ -451,7 +461,15 @@ class JCLCommandManager(CommandManager):
         return (None, result)
 
     execute_reenable_user_1 = select_user_jids_step_1
-    execute_reenable_user_2 = select_accounts_step_2
+
+    def execute_reenable_user_2(self, info_query, session_context,
+                                command_node, lang_class):
+        self.__logger.debug("Executing 'reenable-user' step 2")
+        self.add_actions(command_node, [ACTION_PREVIOUS, ACTION_COMPLETE], 1)
+        return (self.add_form_select_accounts(session_context, command_node,
+                                              lang_class,
+                                              Account.q.enabled==False),
+                [])
 
     def execute_reenable_user_3(self, info_query, session_context,
                                 command_node, lang_class):
@@ -465,7 +483,15 @@ class JCLCommandManager(CommandManager):
         return (None, result)
 
     execute_end_user_session_1 = select_user_jids_step_1
-    execute_end_user_session_2 = select_accounts_step_2
+
+    def execute_end_user_session_2(self, info_query, session_context,
+                                   command_node, lang_class):
+        self.__logger.debug("Executing 'end-user-session' step 2")
+        self.add_actions(command_node, [ACTION_PREVIOUS, ACTION_COMPLETE], 1)
+        return (self.add_form_select_accounts(session_context, command_node,
+                                              lang_class,
+                                              Account.q._status != account.OFFLINE),
+                [])
 
     def execute_end_user_session_3(self, info_query, session_context,
                                    command_node, lang_class):
@@ -489,7 +515,7 @@ class JCLCommandManager(CommandManager):
         result_form.add_field(field_type="hidden",
                               name="FORM_TYPE",
                               value="http://jabber.org/protocol/admin")
-        name, user_jid = session_context["account_name"].split("/", 1)[:2]
+        name, user_jid = session_context["account_name"][0].split("/", 1)[:2]
         _account = account.get_account(user_jid, name)
         result_form.fields.append(FieldNoType(name="accountjids",
                                               value=user_jid))
@@ -516,9 +542,9 @@ class JCLCommandManager(CommandManager):
     def execute_change_user_password_3(self, info_query, session_context,
                                        command_node, lang_class):
         self.__logger.debug("Executing command 'change-user-password' step 2")
-        _account = account.get_account(session_context["user_jid"],
+        _account = account.get_account(session_context["user_jid"][0],
-                                       session_context["account_name"])
+                                       session_context["account_name"][0])
-        _account.password = session_context["password"]
+        _account.password = session_context["password"][0]
         command_node.setProp("status", STATUS_COMPLETED)
         return (None, [])
 
@@ -538,7 +564,7 @@ class JCLCommandManager(CommandManager):
         result_form.add_field(field_type="hidden",
                               name="FORM_TYPE",
                               value="http://jabber.org/protocol/admin")
-        user_jid = session_context["user_jid"]
+        user_jid = session_context["user_jid"][0]
         result_form.fields.append(FieldNoType(name="user_jid",
                                               value=user_jid))
         result_form.as_xml(command_node)

src/jcl/jabber/tests/command.py

@@ -175,6 +175,67 @@ class JCLCommandManager_TestCase(JCLTestCase):
         self.assertEquals(options[3].children.content,
                           "account12/test1@test.com")
 
+    def test_add_form_select_accounts_filtered(self):
+        self.comp.account_manager.account_classes = (ExampleAccount,
+                                                     Example2Account)
+        model.db_connect()
+        account11 = ExampleAccount(user_jid="test1@test.com",
+                                   name="account11",
+                                   jid="account11@jcl.test.com")
+        account12 = Example2Account(user_jid="test1@test.com",
+                                    name="account12",
+                                    jid="account12@jcl.test.com")
+        account21 = ExampleAccount(user_jid="test2@test.com",
+                                   name="account21",
+                                   jid="account21@jcl.test.com")
+        account21.enabled = False
+        account22 = ExampleAccount(user_jid="test2@test.com",
+                                   name="account11",
+                                   jid="account11@jcl.test.com")
+        account31 = ExampleAccount(user_jid="test3@test.com",
+                                   name="account31",
+                                   jid="account31@jcl.test.com")
+        account32 = Example2Account(user_jid="test3@test.com",
+                                    name="account32",
+                                    jid="account32@jcl.test.com")
+        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")
+        session_context = {}
+        session_context["user_jids"] = ["test1@test.com", "test2@test.com"]
+        self.command_manager.add_form_select_accounts(session_context,
+                                                      command_node,
+                                                      Lang.en,
+                                                      Account.q.enabled==True)
+        fields = info_query.xpath_eval("c:command/data:x/data:field",
+                                       {"c": "http://jabber.org/protocol/commands",
+                                        "data": "jabber:x:data"})
+        self.assertEquals(len(fields), 1)
+        self.assertEquals(fields[0].prop("var"), "account_names")
+        self.assertEquals(fields[0].prop("type"), "list-multi")
+        self.assertEquals(fields[0].prop("label"), "Account")
+        options = info_query.xpath_eval("c:command/data:x/data:field[1]/data:option",
+                                        {"c": "http://jabber.org/protocol/commands",
+                                         "data": "jabber:x:data"})
+        self.assertEquals(len(options), 3)
+        self.assertEquals(options[0].prop("label"),
+                          "account11 (Example) (test1@test.com)")
+        self.assertEquals(options[0].children.name, "value")
+        self.assertEquals(options[0].children.content,
+                          "account11/test1@test.com")
+        self.assertEquals(options[1].prop("label"),
+                          "account11 (Example) (test2@test.com)")
+        self.assertEquals(options[1].children.name, "value")
+        self.assertEquals(options[1].children.content,
+                          "account11/test2@test.com")
+        self.assertEquals(options[2].prop("label"),
+                          "account12 (Example2) (test1@test.com)")
+        self.assertEquals(options[2].children.name, "value")
+        self.assertEquals(options[2].children.content,
+                          "account12/test1@test.com")
+
     def test_add_form_select_account(self):
         self.comp.account_manager.account_classes = (ExampleAccount,
                                                      Example2Account)
@@ -203,7 +264,7 @@ class JCLCommandManager_TestCase(JCLTestCase):
                         to_jid="jcl.test.com")
         command_node = info_query.set_new_content(command.COMMAND_NS, "command")
         session_context = {}
-        session_context["user_jid"] = "test1@test.com"
+        session_context["user_jid"] = ["test1@test.com"]
         self.command_manager.add_form_select_account(session_context,
                                                      command_node,
                                                      Lang.en)
@@ -298,8 +359,8 @@ class JCLCommandManager_TestCase(JCLTestCase):
                                        "data": "jabber:x:data"})
         self.assertEquals(len(fields), 6)
         context_session = self.command_manager.sessions[session_id][1]
-        self.assertEquals(context_session["account_type"], "Example")
+        self.assertEquals(context_session["account_type"], ["Example"])
-        self.assertEquals(context_session["user_jid"], "user2@test.com")
+        self.assertEquals(context_session["user_jid"], ["user2@test.com"])
 
         # Third step
         info_query = Iq(stanza_type="set",
@@ -339,12 +400,12 @@ class JCLCommandManager_TestCase(JCLTestCase):
         self.assertEquals(xml_command.prop("sessionid"), session_id)
         self.__check_actions(result[0])
 
-        self.assertEquals(context_session["name"], "account1")
+        self.assertEquals(context_session["name"], ["account1"])
-        self.assertEquals(context_session["login"], "login1")
+        self.assertEquals(context_session["login"], ["login1"])
-        self.assertEquals(context_session["password"], "pass1")
+        self.assertEquals(context_session["password"], ["pass1"])
-        self.assertEquals(context_session["store_password"], "1")
+        self.assertEquals(context_session["store_password"], ["1"])
-        self.assertEquals(context_session["test_enum"], "choice2")
+        self.assertEquals(context_session["test_enum"], ["choice2"])
-        self.assertEquals(context_session["test_int"], "42")
+        self.assertEquals(context_session["test_int"], ["42"])
 
         model.db_connect()
         _account = account.get_account("user2@test.com",
@@ -455,8 +516,8 @@ class JCLCommandManager_TestCase(JCLTestCase):
                                        "data": "jabber:x:data"})
         self.assertEquals(len(fields), 6)
         context_session = self.command_manager.sessions[session_id][1]
-        self.assertEquals(context_session["account_type"], "Example")
+        self.assertEquals(context_session["account_type"], ["Example"])
-        self.assertEquals(context_session["user_jid"], "user2@test.com")
+        self.assertEquals(context_session["user_jid"], ["user2@test.com"])
 
         # First step again
         info_query = Iq(stanza_type="set",
@@ -722,105 +783,7 @@ class JCLCommandManager_TestCase(JCLTestCase):
         account11 = ExampleAccount(user_jid="test1@test.com",
                                    name="account11",
                                    jid="account11@jcl.test.com")
-        account12 = Example2Account(user_jid="test1@test.com",
+        account11.enabled = True
-                                    name="account12",
-                                    jid="account12@jcl.test.com")
-        account21 = ExampleAccount(user_jid="test2@test.com",
-                                   name="account21",
-                                   jid="account21@jcl.test.com")
-        account22 = ExampleAccount(user_jid="test2@test.com",
-                                   name="account11",
-                                   jid="account11@jcl.test.com")
-        account31 = ExampleAccount(user_jid="test3@test.com",
-                                   name="account31",
-                                   jid="account31@jcl.test.com")
-        account32 = Example2Account(user_jid="test3@test.com",
-                                    name="account32",
-                                    jid="account32@jcl.test.com")
-        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#disable-user")
-        result = self.command_manager.apply_command_action(info_query,
-                                                           "http://jabber.org/protocol/admin#disable-user",
-                                                           "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"])
-
-        # 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#disable-user")
-        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="jid-multi",
-                              name="user_jids",
-                              values=["test1@test.com", "test2@test.com"])
-        submit_form.as_xml(command_node)
-        result = self.command_manager.apply_command_action(info_query,
-                                                           "http://jabber.org/protocol/admin#disable-user",
-                                                           "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.assertEquals(xml_command.prop("sessionid"), session_id)
-        self.__check_actions(result[0], ["prev", "complete"], 1)
-        context_session = self.command_manager.sessions[session_id][1]
-        self.assertEquals(context_session["user_jids"],
-                          ["test1@test.com", "test2@test.com"])
-
-        # Third 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#disable-user")
-        command_node.setProp("sessionid", session_id)
-        command_node.setProp("action", "complete")
-        submit_form = Form(xmlnode_or_type="submit")
-        submit_form.add_field(field_type="list-multi",
-                              name="account_names",
-                              values=["account11/test1@test.com",
-                                      "account11/test2@test.com"])
-        submit_form.as_xml(command_node)
-        result = self.command_manager.apply_command_action(info_query,
-                                                           "http://jabber.org/protocol/admin#disable-user",
-                                                           "execute")
-        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])
-        self.assertEquals(context_session["account_names"],
-                          ["account11/test1@test.com",
-                           "account11/test2@test.com"])
-        for _account in account.get_all_accounts():
-            if _account.name == "account11":
-                self.assertFalse(_account.enabled)
-            else:
-                self.assertTrue(_account.enabled)
-
-    def test_execute_reenable_user(self):
-        self.comp.account_manager.account_classes = (ExampleAccount,
-                                                     Example2Account)
-        model.db_connect()
-        account11 = ExampleAccount(user_jid="test1@test.com",
-                                   name="account11",
-                                   jid="account11@jcl.test.com")
-        account11.enabled = False
         account12 = Example2Account(user_jid="test1@test.com",
                                     name="account12",
                                     jid="account12@jcl.test.com")
@@ -832,7 +795,7 @@ class JCLCommandManager_TestCase(JCLTestCase):
         account22 = ExampleAccount(user_jid="test2@test.com",
                                    name="account11",
                                    jid="account11@jcl.test.com")
-        account22.enabled = False
+        account22.enabled = True
         account31 = ExampleAccount(user_jid="test3@test.com",
                                    name="account31",
                                    jid="account31@jcl.test.com")
@@ -846,6 +809,111 @@ class JCLCommandManager_TestCase(JCLTestCase):
                         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#disable-user")
+        result = self.command_manager.apply_command_action(info_query,
+                                                           "http://jabber.org/protocol/admin#disable-user",
+                                                           "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"])
+
+        # 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#disable-user")
+        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="jid-multi",
+                              name="user_jids",
+                              values=["test1@test.com", "test2@test.com"])
+        submit_form.as_xml(command_node)
+        result = self.command_manager.apply_command_action(info_query,
+                                                           "http://jabber.org/protocol/admin#disable-user",
+                                                           "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.assertEquals(xml_command.prop("sessionid"), session_id)
+        self.__check_actions(result[0], ["prev", "complete"], 1)
+        context_session = self.command_manager.sessions[session_id][1]
+        self.assertEquals(context_session["user_jids"],
+                          ["test1@test.com", "test2@test.com"])
+        options = result[0].xpath_eval("c:command/data:x/data:field[1]/data:option",
+                                       {"c": "http://jabber.org/protocol/commands",
+                                        "data": "jabber:x:data"})
+        self.assertEquals(len(options), 2)
+
+        # Third 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#disable-user")
+        command_node.setProp("sessionid", session_id)
+        command_node.setProp("action", "complete")
+        submit_form = Form(xmlnode_or_type="submit")
+        submit_form.add_field(field_type="list-multi",
+                              name="account_names",
+                              values=["account11/test1@test.com",
+                                      "account11/test2@test.com"])
+        submit_form.as_xml(command_node)
+        result = self.command_manager.apply_command_action(info_query,
+                                                           "http://jabber.org/protocol/admin#disable-user",
+                                                           "execute")
+        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])
+        self.assertEquals(context_session["account_names"],
+                          ["account11/test1@test.com",
+                           "account11/test2@test.com"])
+        for _account in account.get_all_accounts():
+            self.assertFalse(_account.enabled)
+
+    def test_execute_reenable_user(self):
+        self.comp.account_manager.account_classes = (ExampleAccount,
+                                                     Example2Account)
+        model.db_connect()
+        account11 = ExampleAccount(user_jid="test1@test.com",
+                                   name="account11",
+                                   jid="account11@jcl.test.com")
+        account11.enabled = False
+        account12 = Example2Account(user_jid="test1@test.com",
+                                    name="account12",
+                                    jid="account12@jcl.test.com")
+        account12.enabled = True
+        account21 = ExampleAccount(user_jid="test2@test.com",
+                                   name="account21",
+                                   jid="account21@jcl.test.com")
+        account21.enabled = True
+        account22 = ExampleAccount(user_jid="test2@test.com",
+                                   name="account11",
+                                   jid="account11@jcl.test.com")
+        account22.enabled = False
+        account31 = ExampleAccount(user_jid="test3@test.com",
+                                   name="account31",
+                                   jid="account31@jcl.test.com")
+        account31.enabled = True
+        account32 = Example2Account(user_jid="test3@test.com",
+                                    name="account32",
+                                    jid="account32@jcl.test.com")
+        account32.enabled = True
+        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#reenable-user")
         result = self.command_manager.apply_command_action(info_query,
                                                            "http://jabber.org/protocol/admin#reenable-user",
@@ -885,6 +953,10 @@ class JCLCommandManager_TestCase(JCLTestCase):
         context_session = self.command_manager.sessions[session_id][1]
         self.assertEquals(context_session["user_jids"],
                           ["test1@test.com", "test2@test.com"])
+        options = result[0].xpath_eval("c:command/data:x/data:field[1]/data:option",
+                                       {"c": "http://jabber.org/protocol/commands",
+                                        "data": "jabber:x:data"})
+        self.assertEquals(len(options), 2)
 
         # Third step
         info_query = Iq(stanza_type="set",
@@ -912,10 +984,7 @@ class JCLCommandManager_TestCase(JCLTestCase):
                           ["account11/test1@test.com",
                            "account11/test2@test.com"])
         for _account in account.get_all_accounts():
-            if _account.name == "account11":
             self.assertTrue(_account.enabled)
-            else:
-                self.assertFalse(_account.enabled)
 
     def test_execute_end_user_session(self):
         self.comp.account_manager.account_classes = (ExampleAccount,
@@ -924,6 +993,7 @@ class JCLCommandManager_TestCase(JCLTestCase):
         account11 = ExampleAccount(user_jid="test1@test.com",
                                    name="account11",
                                    jid="account11@jcl.test.com")
+        account11.status = account.ONLINE
         account12 = Example2Account(user_jid="test1@test.com",
                                     name="account12",
                                     jid="account12@jcl.test.com")
@@ -933,6 +1003,7 @@ class JCLCommandManager_TestCase(JCLTestCase):
         account22 = ExampleAccount(user_jid="test2@test.com",
                                    name="account11",
                                    jid="account11@jcl.test.com")
+        account22.status = account.ONLINE
         account31 = ExampleAccount(user_jid="test3@test.com",
                                    name="account31",
                                    jid="account31@jcl.test.com")
@@ -983,6 +1054,10 @@ class JCLCommandManager_TestCase(JCLTestCase):
         context_session = self.command_manager.sessions[session_id][1]
         self.assertEquals(context_session["user_jids"],
                           ["test1@test.com", "test2@test.com"])
+        options = result[0].xpath_eval("c:command/data:x/data:field[1]/data:option",
+                                       {"c": "http://jabber.org/protocol/commands",
+                                        "data": "jabber:x:data"})
+        self.assertEquals(len(options), 2)
 
         # Third step
         info_query = Iq(stanza_type="set",
@@ -1089,7 +1164,7 @@ class JCLCommandManager_TestCase(JCLTestCase):
         self.__check_actions(result[0], ["prev", "complete"], 1)
         context_session = self.command_manager.sessions[session_id][1]
         self.assertEquals(context_session["user_jid"],
-                          "test1@test.com")
+                          ["test1@test.com"])
 
         # Third step
         info_query = Iq(stanza_type="set",
@@ -1113,7 +1188,7 @@ class JCLCommandManager_TestCase(JCLTestCase):
         self.assertEquals(xml_command.prop("sessionid"), session_id)
         self.__check_actions(result[0])
         self.assertEquals(context_session["account_name"],
-                          "account11/test1@test.com")
+                          ["account11/test1@test.com"])
         stanza_sent = result
         self.assertEquals(len(stanza_sent), 1)
         iq_result = stanza_sent[0]
@@ -1199,7 +1274,7 @@ class JCLCommandManager_TestCase(JCLTestCase):
         self.__check_actions(result[0], ["prev", "complete"], 1)
         context_session = self.command_manager.sessions[session_id][1]
         self.assertEquals(context_session["user_jid"],
-                          "test1@test.com")
+                          ["test1@test.com"])
 
         # Third step
         info_query = Iq(stanza_type="set",
@@ -1226,9 +1301,9 @@ class JCLCommandManager_TestCase(JCLTestCase):
         self.assertEquals(xml_command.prop("sessionid"), session_id)
         self.__check_actions(result[0])
         self.assertEquals(context_session["account_name"],
-                          "account11")
+                          ["account11"])
         self.assertEquals(context_session["password"],
-                          "pass2")
+                          ["pass2"])
         self.assertEquals(account11.password, "pass2")
 
     def test_execute_get_user_roster(self):
@@ -1308,7 +1383,7 @@ class JCLCommandManager_TestCase(JCLTestCase):
         self.__check_actions(result[0])
         context_session = self.command_manager.sessions[session_id][1]
         self.assertEquals(context_session["user_jid"],
-                          "test1@test.com")
+                          ["test1@test.com"])
         fields = result[0].xpath_eval("c:command/data:x/data:field",
                                       {"c": "http://jabber.org/protocol/commands",
                                        "data": "jabber:x:data"})

src/jcl/model/account.py

@@ -64,7 +64,7 @@ class Account(InheritableSQLObject):
     user_jid = StringCol()
     name = StringCol()
     jid = StringCol()
-    __status = StringCol(default=OFFLINE, dbName="status")
+    _status = StringCol(default=OFFLINE, dbName="status")
     in_error = BoolCol(default=False)
     legacy_jids = MultipleJoin('LegacyJID')
     enabled = BoolCol(default=True)
@@ -91,7 +91,7 @@ class Account(InheritableSQLObject):
 
     def get_status(self):
         """Return current Jabber status"""
-        return self.__status
+        return self._status
 
     def set_status(self, status):
         """Set current Jabber status"""
@@ -106,7 +106,7 @@ class Account(InheritableSQLObject):
             # TODO seems to be a bug : first_check = True only
             # if previous status was OFFLINE
             self.first_check = True
-        self.__status = status
+        self._status = status
 
     status = property(get_status, set_status)
 
@@ -151,10 +151,14 @@ def get_account(bare_user_jid, name, account_class=Account):
     model.db_disconnect()
     return result
 
-def get_accounts(bare_user_jid, account_class=Account):
+def get_accounts(bare_user_jid, account_class=Account, filter=None):
     model.db_connect()
-    accounts = account_class.select(\
+    if filter is not None:
-        account_class.q.user_jid == unicode(bare_user_jid))
+        filter = AND(account_class.q.user_jid == unicode(bare_user_jid),
+                     filter)
+    else:
+        filter = account_class.q.user_jid == unicode(bare_user_jid)
+    accounts = account_class.select(filter)
     if accounts.count() == 0:
         model.db_disconnect()
         return

src/jcl/tests/__init__.py

@@ -41,11 +41,10 @@ class JCLTestCase(unittest.TestCase):
         if os.path.exists(self.db_path):
             os.unlink(self.db_path)
 
+def suite():
     from jcl.tests import lang, runner
     from jcl.jabber import tests as jabber
     from jcl.model import tests as model
-
-def suite():
     suite = unittest.TestSuite()
     suite.addTest(lang.suite())
     suite.addTest(runner.suite())