More tests

darcs-hash:20080520173654-86b55-8e41007c4d8170cf7a087e1e13db35b84784c9ce.gz

src/jcl/jabber/disco.py

@@ -129,7 +129,10 @@ class AccountTypeDiscoGetItemsHandler(DiscoHandler):
         self.__logger = logging.getLogger("jcl.jabber.AccountTypeDiscoGetItemsHandler")
 
     def handle(self, stanza, lang_class, node, disco_obj, data):
-        """Discovery get_items on an account type node"""
+        """
+        Discovery get_items on an account type node:
+        return account list
+        """
         account_type = data
         from_jid = stanza.get_from()
         self.__logger.debug("Listing account for " + account_type)

src/jcl/jabber/tests/__init__.py

@@ -5,7 +5,8 @@ import unittest
 
 import jcl.jabber as jabber
 
-from jcl.jabber.tests import component, feeder, command, message, presence
+from jcl.jabber.tests import component, feeder, command, message, presence, \
+    disco
 
 class HandlerType1:
     pass
@@ -36,6 +37,7 @@ def suite():
     test_suite.addTest(command.suite())
     test_suite.addTest(message.suite())
     test_suite.addTest(presence.suite())
+    test_suite.addTest(disco.suite())
     return test_suite
 
 if __name__ == '__main__':

src/jcl/model/__init__.py

@@ -17,8 +17,7 @@ def db_connect():
     pool) associated to the current thread.
     """
     #if not jcl.model.db_connected:
-    jcl.model.hub.threadConnection = \
+    jcl.model.hub.threadConnection = connectionForURI(db_connection_str)
-        connectionForURI(db_connection_str)
     #        account.hub.threadConnection.debug = True
     #jcl.model.db_connected = True
 

src/jcl/runner.py

@@ -115,8 +115,8 @@ class JCLRunner(object):
             cleanopts[arg][1](value)
 
     def __apply_configfile(self, commandline_args, cleanopts):
-        if commandline_args.has_key("config_file"):
+        if commandline_args.has_key("config-file"):
-            self.config_file = commandline_args["config_file"]
+            self.config_file = commandline_args["config-file"]
         elif commandline_args.has_key("c"):
             self.config_file = commandline_args["c"]
         self.config = ConfigParser()
@@ -162,6 +162,8 @@ class JCLRunner(object):
         if commandline_args.has_key("debug") or commandline_args.has_key("d"):
             self.debug = True
             self.logger.debug("Debug activated")
+        else:
+            self.debug = False
         self.__apply_configfile(commandline_args, cleanopts)
         self.__apply_commandline_args(commandline_args, cleanopts)
         if self.log_stdout:
@@ -195,7 +197,6 @@ class JCLRunner(object):
 
     debug = property(get_debug, set_debug)
 
-
     def setup_db(self):
         Account.createTable(ifNotExists=True)
         PresenceAccount.createTable(ifNotExists=True)

src/jcl/tests/runner.py

@@ -24,14 +24,15 @@ import unittest
 import sys
 import os
 import tempfile
+import logging
 
 from sqlobject import *
 
 import jcl
 from jcl.runner import JCLRunner
-
 import jcl.model as model
 from jcl.model.account import Account, PresenceAccount, User, LegacyJID
+from jcl.jabber.component import JCLComponent
 
 if sys.platform == "win32":
     DB_DIR = "/c|/temp/"
@@ -57,6 +58,8 @@ class JCLRunner_TestCase(unittest.TestCase):
         self.assertEquals(self.runner.db_url, "sqlite:///var/spool/jabber/jcl.db")
         self.assertEquals(self.runner.pid_file, "/var/run/jabber/jcl.pid")
         self.assertFalse(self.runner.debug)
+        self.assertEquals(self.runner.logger.getEffectiveLevel(),
+                          logging.CRITICAL)
 
     def test_configure_configfile(self):
         self.runner.config_file = "src/jcl/tests/jcl.conf"
@@ -69,6 +72,8 @@ class JCLRunner_TestCase(unittest.TestCase):
         self.assertEquals(self.runner.db_url, "test_sqlite://root@localhost/var/spool/jabber/test_jcl.db")
         self.assertEquals(self.runner.pid_file, "/var/run/jabber/test_jcl.pid")
         self.assertFalse(self.runner.debug)
+        self.assertEquals(self.runner.logger.getEffectiveLevel(),
+                          logging.CRITICAL)
 
     def test_configure_uncomplete_configfile(self):
         self.runner.config_file = "src/jcl/tests/uncomplete_jcl.conf"
@@ -82,15 +87,17 @@ class JCLRunner_TestCase(unittest.TestCase):
         # pid_file is not in uncmplete_jcl.conf, must be default value
         self.assertEquals(self.runner.pid_file, "/var/run/jabber/jcl.pid")
         self.assertFalse(self.runner.debug)
+        self.assertEquals(self.runner.logger.getEffectiveLevel(),
+                          logging.CRITICAL)
 
     def test_configure_commandline_shortopt(self):
-        sys.argv = ["", "-c", "src/jcl/tests/jcl.conf", \
+        sys.argv = ["", "-c", "src/jcl/test/jcl.conf",
-                    "-S", "test2_localhost", \
+                    "-S", "test2_localhost",
-                    "-P", "43", \
+                    "-P", "43",
-                    "-s", "test2_secret", \
+                    "-s", "test2_secret",
-                    "-j", "test2_jcl.localhost", \
+                    "-j", "test2_jcl.localhost",
-                    "-l", "test2_en", \
+                    "-l", "test2_en",
-                    "-u", "sqlite:///tmp/test_jcl.db", \
+                    "-u", "sqlite:///tmp/test_jcl.db",
                     "-p", "/tmp/test_jcl.pid"]
         self.runner.configure()
         self.assertEquals(self.runner.server, "test2_localhost")
@@ -101,15 +108,17 @@ class JCLRunner_TestCase(unittest.TestCase):
         self.assertEquals(self.runner.db_url, "sqlite:///tmp/test_jcl.db")
         self.assertEquals(self.runner.pid_file, "/tmp/test_jcl.pid")
         self.assertFalse(self.runner.debug)
+        self.assertEquals(self.runner.logger.getEffectiveLevel(),
+                          logging.CRITICAL)
 
     def test_configure_commandline_longopt(self):
-        sys.argv = ["", "--config-file", "src/jcl/tests/jcl.conf", \
+        sys.argv = ["", "--config-file", "src/jcl/tests/jcl.conf",
-                    "--server", "test2_localhost", \
+                    "--server", "test2_localhost",
-                    "--port", "43", \
+                    "--port", "43",
-                    "--secret", "test2_secret", \
+                    "--secret", "test2_secret",
-                    "--service-jid", "test2_jcl.localhost", \
+                    "--service-jid", "test2_jcl.localhost",
-                    "--language", "test2_en", \
+                    "--language", "test2_en",
-                    "--db-url", "sqlite:///tmp/test_jcl.db", \
+                    "--db-url", "sqlite:///tmp/test_jcl.db",
                     "--pid-file", "/tmp/test_jcl.pid"]
         self.runner.configure()
         self.assertEquals(self.runner.server, "test2_localhost")
@@ -120,6 +129,66 @@ class JCLRunner_TestCase(unittest.TestCase):
         self.assertEquals(self.runner.db_url, "sqlite:///tmp/test_jcl.db")
         self.assertEquals(self.runner.pid_file, "/tmp/test_jcl.pid")
         self.assertFalse(self.runner.debug)
+        self.assertEquals(self.runner.logger.getEffectiveLevel(),
+                          logging.CRITICAL)
+
+    def test_configure_commandline_shortopts_configfile(self):
+        sys.argv = ["", "-c", "src/jcl/tests/jcl.conf"]
+        self.runner.configure()
+        self.assertEquals(self.runner.server, "test_localhost")
+        self.assertEquals(self.runner.port, 42)
+        self.assertEquals(self.runner.secret, "test_secret")
+        self.assertEquals(self.runner.service_jid, "test_jcl.localhost")
+        self.assertEquals(self.runner.language, "test_en")
+        self.assertEquals(self.runner.db_url, "test_sqlite://root@localhost/var/spool/jabber/test_jcl.db")
+        self.assertEquals(self.runner.pid_file, "/var/run/jabber/test_jcl.pid")
+        self.assertFalse(self.runner.debug)
+        self.assertEquals(self.runner.logger.getEffectiveLevel(),
+                          logging.CRITICAL)
+
+    def test_configure_commandline_longopts_configfile(self):
+        sys.argv = ["", "--config-file", "src/jcl/tests/jcl.conf"]
+        self.runner.configure()
+        self.assertEquals(self.runner.server, "test_localhost")
+        self.assertEquals(self.runner.port, 42)
+        self.assertEquals(self.runner.secret, "test_secret")
+        self.assertEquals(self.runner.service_jid, "test_jcl.localhost")
+        self.assertEquals(self.runner.language, "test_en")
+        self.assertEquals(self.runner.db_url, "test_sqlite://root@localhost/var/spool/jabber/test_jcl.db")
+        self.assertEquals(self.runner.pid_file, "/var/run/jabber/test_jcl.pid")
+        self.assertFalse(self.runner.debug)
+        self.assertEquals(self.runner.logger.getEffectiveLevel(),
+                          logging.CRITICAL)
+
+    def test_configure_commandline_short_debug(self):
+        sys.argv = ["", "-d"]
+        old_debug_func = self.runner.logger.debug
+        old_info_func = self.runner.logger.debug
+        try:
+            self.runner.logger.debug = lambda msg: None
+            self.runner.logger.info = lambda msg: None
+            self.runner.configure()
+            self.assertTrue(self.runner.debug)
+            self.assertEquals(self.runner.logger.getEffectiveLevel(),
+                              logging.DEBUG)
+        finally:
+            self.runner.logger.debug = old_debug_func
+            self.runner.logger.info = old_info_func
+
+    def test_configure_commandline_long_debug(self):
+        sys.argv = ["", "--debug"]
+        old_debug_func = self.runner.logger.debug
+        old_info_func = self.runner.logger.debug
+        try:
+            self.runner.logger.debug = lambda msg: None
+            self.runner.logger.info = lambda msg: None
+            self.runner.configure()
+            self.assertTrue(self.runner.debug)
+            self.assertEquals(self.runner.logger.getEffectiveLevel(),
+                              logging.DEBUG)
+        finally:
+            self.runner.logger.debug = old_debug_func
+            self.runner.logger.info = old_info_func
 
     def test_setup_pidfile(self):
         try:
@@ -132,6 +201,33 @@ class JCLRunner_TestCase(unittest.TestCase):
         finally:
             os.remove("/tmp/jcl.pid")
 
+    def test_run(self):
+        """Test if run method of JCLComponent is executed"""
+        self.has_run_func = False
+        def run_func(component_self):
+            self.has_run_func = True
+            return False
+
+        self.runner.pid_file = "/tmp/jcl.pid"
+        db_path = tempfile.mktemp("db", "jcltest", DB_DIR)
+        db_url = "sqlite://" + db_path
+        self.runner.db_url = db_url
+        self.runner.config = None
+        old_run_func = JCLComponent.run
+        JCLComponent.run = run_func
+        try:
+            self.runner.run()
+        finally:
+            JCLComponent.run = old_run_func
+        self.assertTrue(self.has_run_func)
+        Account.dropTable()
+        PresenceAccount.dropTable()
+        User.dropTable()
+        LegacyJID.dropTable()
+        model.db_disconnect()
+        os.unlink(db_path)
+        self.assertFalse(os.access("/tmp/jcl.pid", os.F_OK))
+
     def test__run(self):
         self.runner.pid_file = "/tmp/jcl.pid"
         db_path = tempfile.mktemp("db", "jcltest", DB_DIR)