Update presence status when sending an error

darcs-hash:20080514061608-86b55-c4e4b28df57c96915d9f4d661e9cf26e124e8147.gz

src/jcl/jabber/component.py

@@ -219,8 +219,8 @@ class AccountManager(object):
                 getattr(_account, "populate_handler")()
             except Exception, exception:
                 self.__logger.error("Error in timer thread:", exc_info=True)
-                result.extend(self.send_error_from_account(_account,
+                result.extend(self.get_account_error_stanzas(_account,
-                                                           exception))
+                                                             exception))
 
         if first_account:
             # component subscribe user presence when registering the first
@@ -388,7 +388,6 @@ class AccountManager(object):
         if necessary"""
         result = []
         model.db_connect()
-        _account.default_lang_class = lang_class
         old_status = _account.status
         _account.status = account.ONLINE
         if _account.error is not None:
@@ -553,20 +552,29 @@ class AccountManager(object):
         model.db_disconnect()
         return result
 
-    def send_error_from_account(self, _account, exception):
+    def get_account_error_stanzas(self, _account, exception):
         """Send an error message only one time until _account.error
         has been reset to None"""
         result = []
-        if _account.error == None:
+        str_exception = str(exception)
-            _account.error = str(exception)
+        if _account.error != str_exception:
+            _account.error = str_exception
             result.append(Message(from_jid=_account.jid,
                                   to_jid=_account.user.jid,
                                   stanza_type="error",
                                   subject=_account.default_lang_class.error_subject,
                                   body=_account.default_lang_class.error_body \
                                       % (exception)))
+            result.extend(self.get_account_presence_available(\
+                    _account, _account.default_lang_class))
         return result
 
+    def cancel_account_error(self, _account):
+        """Reset Account error status and send new available presence"""
+        _account.error = None
+        return self.get_account_presence_available(_account,
+                                                   _account.default_lang_class)
+
 ###############################################################################
 # JCL implementation
 ###############################################################################
@@ -1054,7 +1062,8 @@ class JCLComponent(Component, object):
     ###########################################################################
     def send_error(self, _account, exception):
         """ """
-        self.send_stanzas(self.account_manager.send_error_from_account(_account, exception))
+        self.send_stanzas(self.account_manager.get_account_error_stanzas(\
+                _account, exception))
         self.__logger.debug("Error: ", exc_info=True)
 
     def get_config_parameter(self, section, parameter):

src/jcl/jabber/presence.py

@@ -82,6 +82,7 @@ class AccountPresenceHandler(Handler):
 
 class AccountPresenceAvailableHandler(AccountPresenceHandler):
     def get_account_presence(self, stanza, lang_class, _account):
+        _account.default_lang_class = lang_class
         return self.component.account_manager.get_account_presence_available(\
             _account, lang_class)
 

src/jcl/jabber/tests/component.py

@@ -2772,28 +2772,31 @@ class JCLComponent_TestCase(JCLTestCase):
     def test_send_error_first(self):
         self.comp.stream = MockStream()
         self.comp.stream_class = MockStream
-        model.db_connect()
         _account = Account(user=User(jid="user1@test.com"),
                            name="account11",
                            jid="account11@jcl.test.com")
         exception = Exception("test exception")
         self.assertEqual(_account.error, None)
         self.comp.send_error(_account, exception)
-        self.assertEqual(len(self.comp.stream.sent), 1)
+        self.assertEqual(len(self.comp.stream.sent), 2)
         error_sent = self.comp.stream.sent[0]
         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)
+        self.assertEqual(error_sent.get_subject(),
-        self.assertEqual(error_sent.get_body(), _account.default_lang_class.error_body \
+                         _account.default_lang_class.error_subject)
-                         % (exception))
+        self.assertEqual(error_sent.get_body(),
+                         _account.default_lang_class.error_body % (exception))
+        new_presence = self.comp.stream.sent[1].xmlnode
+        self.assertEquals(new_presence.prop("to"), _account.user.jid)
+        self.assertEquals(new_presence.prop("from"), _account.jid)
+        self.assertEquals(new_presence.children.name, "show")
+        self.assertEquals(new_presence.children.content, "dnd")
         self.assertEqual(_account.error, "test exception")
-        model.db_disconnect()
 
     def test_send_error_second(self):
         self.comp.stream = MockStream()
         self.comp.stream_class = MockStream
-        model.db_connect()
         _account = Account(user=User(jid="user1@test.com"),
                            name="account11",
                            jid="account11@jcl.test.com")
@@ -3156,15 +3159,36 @@ class AccountManager_TestCase(JCLTestCase):
         self.assertFalse(account11.populate_handler_called)
         result = self.account_manager.populate_account(account11, Lang.en,
                                                        x_data, False, False)
-        self.assertEquals(len(result), 2)
+        self.assertEquals(len(result), 3)
         self.assertEquals(result[0].get_type(), "error")
         self.assertEquals(result[0].get_from(), "account11@jcl.test.com")
         self.assertEquals(result[0].get_to(), "test1@test.com")
-        self.assertEquals(result[1].get_type(), None)
+        self.assertEquals(result[1].xmlnode.name, "presence")
-        self.assertEquals(result[1].get_from(), "jcl.test.com")
+        self.assertEquals(result[1].get_from(), "account11@jcl.test.com")
         self.assertEquals(result[1].get_to(), "test1@test.com")
+        self.assertEquals(result[1].xmlnode.children.name, "show")
+        self.assertEquals(result[1].xmlnode.children.content, "dnd")
+        self.assertEquals(result[2].get_type(), None)
+        self.assertEquals(result[2].get_from(), "jcl.test.com")
+        self.assertEquals(result[2].get_to(), "test1@test.com")
         self.assertTrue(account11.populate_handler_called)
 
+    def test_cancel_account_error(self):
+        """Test Account error reset"""
+        _account = Account(user=User(jid="user1@test.com"),
+                           name="account11",
+                           jid="account11@jcl.test.com")
+        _account.error = "test exception"
+        result = self.account_manager.cancel_account_error(_account)
+        self.assertEquals(len(result), 1)
+        presence = result[0].xmlnode
+        self.assertEquals(presence.name, "presence")
+        self.assertEquals(presence.prop("type"), None)
+        self.assertEquals(presence.prop("from"), _account.jid)
+        self.assertEquals(presence.prop("to"), _account.user.jid)
+        self.assertEquals(presence.children.name, "show")
+        self.assertEquals(presence.children.content, "online")
+
 def suite():
     test_suite = unittest.TestSuite()
     test_suite.addTest(unittest.makeSuite(JCLComponent_TestCase, 'test'))