Add default SMTP server configuration

darcs-hash:20080520061718-86b55-63ae914b5a132cd49215216ae73ca10c0cef7748.gz

11 files changed, 447 insertions, 172 deletions

diff --git a/src/jmc/jabber/component.py b/src/jmc/jabber/component.py
index 7514582..9a66477 100644
--- a/src/jmc/jabber/component.py
+++ b/src/jmc/jabber/component.py
@@ -33,7 +33,7 @@ from jcl.jabber.feeder import FeederComponent
 from jcl.jabber.command import CommandRootDiscoGetInfoHandler
 from jcl.jabber.component import AccountManager
 from jmc.model.account import IMAPAccount, POP3Account, \
-    SMTPAccount
+    AbstractSMTPAccount, GlobalSMTPAccount, SMTPAccount
 
 from jmc.jabber.disco import MailRootDiscoGetInfoHandler, \
      IMAPAccountDiscoGetItemsHandler, MailAccountTypeDiscoGetInfoHandler, \
diff --git a/src/jmc/jabber/message.py b/src/jmc/jabber/message.py
index f484891..65b453a 100644
--- a/src/jmc/jabber/message.py
+++ b/src/jmc/jabber/message.py
@@ -27,7 +27,7 @@ from pyxmpp.message import Message
 
 from jcl.model import account
 from jmc.jabber import MailHandler
-from jmc.model.account import SMTPAccount
+from jmc.model.account import AbstractSMTPAccount
 
 class SendMailMessageHandler(MailHandler):
     def __init__(self, component):
@@ -90,7 +90,7 @@ class SendMailMessageHandler(MailHandler):
           subject,
           cc_email,
           bcc_email)) = self.get_email_headers_from_message(\
-            message.get_body(), 
+            message.get_body(),
             [self.to_regexp,
              self.subject_regexp,
              self.cc_regexp,
@@ -129,14 +129,14 @@ class RootSendMailMessageHandler(SendMailMessageHandler):
         bare_from_jid = unicode(stanza.get_from().bare())
         accounts = account.get_accounts(\
             bare_from_jid,
-            account_class=SMTPAccount,
-            filter=(SMTPAccount.q.default_account == True))
+            account_class=AbstractSMTPAccount,
+            filter=(AbstractSMTPAccount.q.default_account == True))
         if accounts.count() != 1:
             self.__logger.error("No default account found for user " +
                                 str(bare_from_jid))
         if accounts.count() == 0:
             accounts = account.get_accounts(bare_from_jid,
-                                            SMTPAccount)
+                                            AbstractSMTPAccount)
         return accounts
 
     def handle(self, stanza, lang_class, data):
@@ -147,7 +147,7 @@ class RootSendMailMessageHandler(SendMailMessageHandler):
           subject,
           cc_email,
           bcc_email)) = self.get_email_headers_from_message(\
-            message.get_body(), 
+            message.get_body(),
             [self.to_regexp,
              self.subject_regexp,
              self.cc_regexp,
@@ -177,4 +177,3 @@ class RootSendMailMessageHandler(SendMailMessageHandler):
                             stanza_type="error",
                             subject=lang_class.send_mail_error_no_to_header_subject,
                             body=lang_class.send_mail_error_no_to_header_body)]
-
diff --git a/src/jmc/jabber/tests/command.py b/src/jmc/jabber/tests/command.py
index 372d745..42e36bd 100644
--- a/src/jmc/jabber/tests/command.py
+++ b/src/jmc/jabber/tests/command.py
@@ -39,7 +39,7 @@ import jcl.jabber.command as command
 import jcl.jabber.tests.command
 
 from jmc.model.account import POP3Account, IMAPAccount, SMTPAccount, \
-    MailAccount
+    MailAccount, GlobalSMTPAccount, AbstractSMTPAccount
 from jmc.jabber.component import MailComponent
 from jmc.lang import Lang
 from jmc.jabber.tests.component import MockIMAPAccount
@@ -47,8 +47,9 @@ from jmc.jabber.command import MailCommandManager
 
 class MailCommandManagerTestCase(JCLCommandManagerTestCase):
     def setUp(self, tables=[]):
-        tables += [POP3Account, IMAPAccount, SMTPAccount, MailAccount,
-                   MockIMAPAccount, User, Account, PresenceAccount]
+        tables += [POP3Account, IMAPAccount, GlobalSMTPAccount,
+                   AbstractSMTPAccount, SMTPAccount,
+                   MailAccount, MockIMAPAccount, User, Account, PresenceAccount]
         JCLTestCase.setUp(self, tables=tables)
         self.config_file = tempfile.mktemp(".conf", "jmctest", jcl.tests.DB_DIR)
         self.config = ConfigParser()
@@ -63,6 +64,8 @@ class MailCommandManagerTestCase(JCLCommandManagerTestCase):
         self.command_manager = MailCommandManager(self.comp,
                                                   self.comp.account_manager)
         self.comp.account_manager.account_classes = (POP3Account, IMAPAccount,
+                                                     GlobalSMTPAccount,
+                                                     AbstractSMTPAccount,
                                                      SMTPAccount, MockIMAPAccount)
         self.user1 = User(jid="test1@test.com")
         self.account11 = MockIMAPAccount(user=self.user1,
diff --git a/src/jmc/jabber/tests/component.py b/src/jmc/jabber/tests/component.py
index 03b39d8..7fa4c45 100644
--- a/src/jmc/jabber/tests/component.py
+++ b/src/jmc/jabber/tests/component.py
@@ -42,7 +42,7 @@ from jcl.jabber.tests.presence import DefaultSubscribeHandler_TestCase, \
 from jcl.jabber.tests.feeder import FeederMock, SenderMock
 
 from jmc.model.account import MailAccount, IMAPAccount, POP3Account, \
-     SMTPAccount, NoAccountError
+     GlobalSMTPAccount, AbstractSMTPAccount, SMTPAccount, NoAccountError
 from jmc.jabber import MailHandler
 from jmc.jabber.message import SendMailMessageHandler
 from jmc.jabber.presence import MailSubscribeHandler, \
@@ -192,8 +192,9 @@ class MailComponent_TestCase(JCLTestCase):
     def setUp(self):
         JCLTestCase.setUp(self, tables=[Account, PresenceAccount, User,
                                         MailAccount, IMAPAccount, POP3Account,
-                                        SMTPAccount, MockIMAPAccount,
-                                        MockPOP3Account])
+                                        GlobalSMTPAccount,
+                                        AbstractSMTPAccount, SMTPAccount,
+                                        MockIMAPAccount, MockPOP3Account])
         self.comp = MailComponent("jmc.test.com",
                                   "password",
                                   "localhost",
@@ -1276,7 +1277,9 @@ class MailSender_TestCase(JCLTestCase):
 class MailHandler_TestCase(JCLTestCase):
     def setUp(self, tables=[]):
         self.handler = MailHandler(None)
-        JCLTestCase.setUp(self, tables=[Account, SMTPAccount, User] + tables)
+        JCLTestCase.setUp(self, tables=[Account, AbstractSMTPAccount,
+                                        GlobalSMTPAccount, SMTPAccount, User] \
+                             + tables)
 
     def test_filter(self):
         model.db_connect()
@@ -1470,7 +1473,8 @@ class MailFeederHandler_TestCase(JCLTestCase):
         self.handler = MailFeederHandler(FeederMock(), SenderMock())
         JCLTestCase.setUp(self, tables=[Account, PresenceAccount, MailAccount,
                                         IMAPAccount, POP3Account, SMTPAccount,
-                                        User])
+                                        GlobalSMTPAccount,
+                                        AbstractSMTPAccount, User])
 
     def test_filter(self):
         model.db_connect()
diff --git a/src/jmc/jabber/tests/message.py b/src/jmc/jabber/tests/message.py
index 709ddd4..734440f 100644
--- a/src/jmc/jabber/tests/message.py
+++ b/src/jmc/jabber/tests/message.py
@@ -28,7 +28,8 @@ from pyxmpp.message import Message
 from jcl.tests import JCLTestCase
 from jcl.model.account import Account, User
 
-from jmc.model.account import SMTPAccount
+from jmc.model.account import GlobalSMTPAccount, AbstractSMTPAccount, \
+    SMTPAccount
 from jmc.jabber.message import SendMailMessageHandler, \
     RootSendMailMessageHandler
 from jmc.lang import Lang
@@ -65,7 +66,7 @@ class SendMailMessageHandler_TestCase(unittest.TestCase):
         subject_regexp = re.compile("^\s*(?i)subject\s*:\s*(?P<subject_email>.*)")
         (message, headers) = self.handler.get_email_headers_from_message(\
             "To: dest@test.com\nCc: cc@test.com\n"
-            + "Bcc: bcc@test.com\n" 
+            + "Bcc: bcc@test.com\n"
             + "Subject: test subject\ntest body\n",
             [to_regexp, cc_regexp, bcc_regexp, subject_regexp],
             ["to_email", "cc_email", "bcc_email", "subject_email"])
@@ -121,7 +122,9 @@ class SendMailMessageHandler_TestCase(unittest.TestCase):
 
 class RootSendMailMessageHandler_TestCase(JCLTestCase):
     def setUp(self):
-        JCLTestCase.setUp(self, tables=[Account, SMTPAccount, User])
+        JCLTestCase.setUp(self, tables=[Account, GlobalSMTPAccount,
+                                        AbstractSMTPAccount,
+                                        SMTPAccount, User])
         self.handler = RootSendMailMessageHandler(None)
 
     def test_filter(self):
diff --git a/src/jmc/lang.py b/src/jmc/lang.py
index 1944e24..fa43cf1 100644
--- a/src/jmc/lang.py
+++ b/src/jmc/lang.py
@@ -64,6 +64,7 @@ class Lang(jcl.lang.Lang):
         type_imap_name = u"IMAP accounts"
         type_pop3_name = u"POP3 accounts"
         type_smtp_name = u"SMTP accounts"
+        type_globalsmtp_name = u"Default SMTP Server"
 
         send_mail_error_no_to_header_subject = u"No header \"TO\" found"
         send_mail_error_no_to_header_body = u"No header \"TO\" found in receive message.\n" \
@@ -87,14 +88,14 @@ class Lang(jcl.lang.Lang):
 
         command_force_check = "Force check for new emails"
         command_force_check_1_description = "Select account(s) to check for new emails."
-        
+
         command_get_email = "Fetch emails"
         command_get_email_1_description = "Select email(s) to fetch"
         command_get_email_2_description = "%i emails have been sent"
         field_email_subject = u"Email Subject"
         field_select_more_emails = u"Select more emails to fetch"
         mail_subject = u"Email from %s"
-        
+
     class fr(en, jcl.lang.Lang.fr):
         component_name = u"Jabber Mail Component"
         register_title = u"Enregistrement d'une nouvelle connexion à un " \
diff --git a/src/jmc/model/account.py b/src/jmc/model/account.py
index 29b2470..e5590f3 100644
--- a/src/jmc/model/account.py
+++ b/src/jmc/model/account.py
@@ -691,17 +691,8 @@ class POP3Account(MailAccount):
         self.get_new_mail_list()
         self.lastmail = self.nb_mail
 
-
-class SMTPAccount(Account):
-    """Send email account"""
-
-    login = StringCol(default="")
-    password = StringCol(default=None)
-    host = StringCol(default="localhost")
-    port = IntCol(default=110)
-    tls = BoolCol(default=False)
-    store_password = BoolCol(default=True)
-    waiting_password_reply = BoolCol(default=False)
+class AbstractSMTPAccount(Account):
+    """Common SMTP attribut"""
     default_from = StringCol(default="nobody@localhost")
     default_account = BoolCol(default=False)
 
@@ -709,33 +700,41 @@ class SMTPAccount(Account):
         """SMTPAccount init
         Initialize class attributes"""
         Account._init(self, *args, **kw)
-        self.__logger = logging.getLogger("jmc.model.account.SMTPAccount")
+        self.__logger = logging.getLogger("jmc.model.account.AbstractSMTPAccount")
 
-    def _get_default_port(cls):
-        """Return default SMTP server port"""
-        return 25
+    def get_type(self):
+        if self.tls:
+            return "smtps"
+        return "smtp"
 
-    get_default_port = classmethod(_get_default_port)
+    type = property(get_type)
 
-    def _get_register_fields(cls, real_class=None):
-        """See Account._get_register_fields
-        """
-        def password_post_func(password, default_func, bare_from_jid):
-            if password is None or password == "":
-                return None
-            return password
+    def create_email(self, from_email, to_email, subject, body, other_headers=None):
+        """Create new email"""
+        _email = MIMEText(body)
+        if subject is None:
+            subject = ""
+        _email['Subject'] = Header(str(subject))
+        _email['From'] = Header(str(from_email))
+        _email['To'] = Header(str(to_email))
+        if other_headers is not None:
+            for header_name in other_headers.keys():
+                _email[header_name] = Header(other_headers[header_name])
+        return _email
 
+    def _get_register_fields (cls, real_class=None):
+        """ """
         def default_account_default_func(bare_from_jid):
-            accounts = account.get_accounts(bare_from_jid, SMTPAccount,
-                                            (SMTPAccount.q.default_account == True))
+            accounts = account.get_accounts(bare_from_jid, AbstractSMTPAccount,
+                                            (AbstractSMTPAccount.q.default_account == True))
             if accounts.count() == 0:
                 return True
             else:
                 return False
 
         def default_account_post_func(value, default_func, bare_from_jid):
-            accounts = account.get_accounts(bare_from_jid, SMTPAccount,
-                                            (SMTPAccount.q.default_account == True))
+            accounts = account.get_accounts(bare_from_jid, AbstractSMTPAccount,
+                                            (AbstractSMTPAccount.q.default_account == True))
             already_default_account = (accounts.count() != 0)
             if isinstance(value, str):
                 value = value.lower()
@@ -756,55 +755,48 @@ class SMTPAccount(Account):
         if real_class is None:
             real_class = cls
         return Account.get_register_fields(real_class) + \
-            [("login", "text-single", None,
-              account.default_post_func,
-              lambda bare_from_jid: ""),
-             ("password", "text-private", None, password_post_func,
-              lambda bare_from_jid: ""),
-             ("host", "text-single", None,
-              lambda field_value, default_func, bare_from_jid: \
-                  account.mandatory_field("host", field_value),
-              lambda bare_from_jid: ""),
-             ("port", "text-single", None,
-              account.int_post_func,
-              lambda bare_from_jid: real_class.get_default_port()),
-             ("tls", "boolean", None,
-              account.default_post_func,
-              lambda bare_from_jid: False),
+            [("default_account", "boolean", None,
+              default_account_post_func,
+              default_account_default_func),
              ("default_from", "text-single", None,
               lambda field_value, default_func, bare_from_jid: \
                   account.mandatory_field("default_from", field_value),
-              lambda bare_from_jid: ""),
-             ("store_password", "boolean", None,
-              account.default_post_func,
-              lambda bare_from_jid: True),
-             ("default_account", "boolean", None,
-              default_account_post_func,
-              default_account_default_func)]
+              lambda bare_from_jid: "")]
 
     get_register_fields = classmethod(_get_register_fields)
 
-    get_default_status_msg = _get_default_status_msg
+smtp_default_login = ''
+smtp_default_password = ''
+smtp_default_host = "localhost"
+smtp_default_port = 25
+smtp_default_tls = False
+
+class GlobalSMTPAccount(AbstractSMTPAccount):
+    """SMTP Account to send email with global settings"""
+    login = StringCol(default=lambda: smtp_default_login)
+    password = StringCol(default=lambda: smtp_default_password)
+    host = StringCol(default=lambda: smtp_default_host)
+    port = IntCol(default=lambda: smtp_default_port)
+    tls = BoolCol(default=lambda: smtp_default_tls)
+    store_password = BoolCol(default=True)
+    waiting_password_reply = BoolCol(default=False)
 
-    def get_type(self):
-        if self.tls:
-            return "smtps"
-        return "smtp"
+    def _init(self, *args, **kw):
+        """SMTPAccount init
+        Initialize class attributes"""
+        AbstractSMTPAccount._init(self, *args, **kw)
+        self.__logger = logging.getLogger("jmc.model.account.GlobalSMTPAccount")
 
-    type = property(get_type)
+    def _get_register_fields(cls, real_class=None):
+        """See Account._get_register_fields
+        """
+        if real_class is None:
+            real_class = cls
+        return AbstractSMTPAccount.get_register_fields(real_class)
 
-    def create_email(self, from_email, to_email, subject, body, other_headers=None):
-        """Create new email"""
-        _email = MIMEText(body)
-        if subject is None:
-            subject = ""
-        _email['Subject'] = Header(str(subject))
-        _email['From'] = Header(str(from_email))
-        _email['To'] = Header(str(to_email))
-        if other_headers is not None:
-            for header_name in other_headers.keys():
-                _email[header_name] = Header(other_headers[header_name])
-        return _email
+    get_register_fields = classmethod(_get_register_fields)
+
+    get_default_status_msg = _get_default_status_msg
 
     def __say_hello(self, connection):
         if not (200 <= connection.ehlo()[0] <= 299):
@@ -819,7 +811,6 @@ class SMTPAccount(Account):
         smtp_connection = smtplib.SMTP()
         if self.__logger.getEffectiveLevel() == logging.DEBUG:
             smtp_connection.set_debuglevel(1)
-
 	# It seems there is a bug that set self.port to something that is
 	# not an integer. How ? Here is a temporary workaround.
         from types import IntType
@@ -828,7 +819,6 @@ class SMTPAccount(Account):
                                 + str(type(self.port)) + ", value: "
                                 + str(self.port))
             self.port = int(self.port)
-
         smtp_connection.connect(self.host, self.port)
         self.__say_hello(smtp_connection)
         if self.tls:
@@ -857,3 +847,44 @@ class SMTPAccount(Account):
         smtp_connection.sendmail(str(_email['From']), str(_email['To']),
                                  _email.as_string())
         smtp_connection.quit()
+
+class SMTPAccount(GlobalSMTPAccount):
+    """Send email account"""
+
+    def _init(self, *args, **kw):
+        """SMTPAccount init
+        Initialize class attributes"""
+        GlobalSMTPAccount._init(self, *args, **kw)
+        self.__logger = logging.getLogger("jmc.model.account.SMTPAccount")
+
+    def _get_register_fields(cls, real_class=None):
+        """See Account._get_register_fields
+        """
+        def password_post_func(password, default_func, bare_from_jid):
+            if password is None or password == "":
+                return None
+            return password
+
+        if real_class is None:
+            real_class = cls
+        return GlobalSMTPAccount.get_register_fields(real_class) + \
+            [("login", "text-single", None,
+              account.default_post_func,
+              lambda bare_from_jid: smtp_default_login),
+             ("password", "text-private", None, password_post_func,
+              lambda bare_from_jid: smtp_default_password),
+             ("host", "text-single", None,
+              lambda field_value, default_func, bare_from_jid: \
+                  account.mandatory_field("host", field_value),
+              lambda bare_from_jid: smtp_default_host),
+             ("port", "text-single", None,
+              account.int_post_func,
+              lambda bare_from_jid: smtp_default_port),
+             ("tls", "boolean", None,
+              account.default_post_func,
+              lambda bare_from_jid: smtp_default_tls),
+             ("store_password", "boolean", None,
+              account.default_post_func,
+              lambda bare_from_jid: True)]
+
+    get_register_fields = classmethod(_get_register_fields)
diff --git a/src/jmc/model/tests/account.py b/src/jmc/model/tests/account.py
index 6c07237..e811ce9 100644
--- a/src/jmc/model/tests/account.py
+++ b/src/jmc/model/tests/account.py
@@ -27,7 +27,8 @@ import thread
 from jcl.tests import JCLTestCase
 import jcl.model as model
 from jcl.model.account import Account, PresenceAccount, User
-from jmc.model.account import MailAccount, POP3Account, IMAPAccount, SMTPAccount
+from jmc.model.account import MailAccount, POP3Account, IMAPAccount, \
+    GlobalSMTPAccount, AbstractSMTPAccount, SMTPAccount
 from jmc.lang import Lang
 
 from jcl.model.tests.account import Account_TestCase, \
@@ -795,82 +796,72 @@ class IMAPAccount_TestCase(InheritableAccount_TestCase):
         status_msg = self.imap_account.get_default_status_msg(Lang.en)
         self.assertEquals(status_msg, "imaps://login@localhost:1143")
 
-class SMTPAccount_TestCase(Account_TestCase):
+class AbstractSMTPAccount_TestCase(Account_TestCase):
     def setUp(self):
         JCLTestCase.setUp(self, tables=[Account, ExampleAccount, User,
-                                        SMTPAccount])
-        self.account_class = SMTPAccount
+                                        GlobalSMTPAccount, AbstractSMTPAccount])
+        self.account_class = AbstractSMTPAccount
 
     def test_default_account_post_func_no_default_true(self):
-        model.db_connect()
         user1 = User(jid="user1@test.com")
-        account11 = SMTPAccount(user=user1,
-                                name="account11",
-                                jid="account11@jmc.test.com")
-        account12 = SMTPAccount(user=user1,
-                                name="account12",
-                                jid="account12@jmc.test.com")
+        account11 = AbstractSMTPAccount(user=user1,
+                                        name="account11",
+                                        jid="account11@jmc.test.com")
+        account12 = AbstractSMTPAccount(user=user1,
+                                        name="account12",
+                                        jid="account12@jmc.test.com")
         (name, field_type, field_options, post_func, default_func) = \
-            SMTPAccount.get_register_fields()[7]
+            AbstractSMTPAccount.get_register_fields()[0]
         value = post_func("True", None, "user1@test.com")
         self.assertTrue(value)
-        model.db_disconnect()
 
     def test_default_account_post_func_no_default_false(self):
-        model.db_connect()
         user1 = User(jid="user1@test.com")
-        account11 = SMTPAccount(user=user1,
-                                name="account11",
-                                jid="account11@jmc.test.com")
-        account12 = SMTPAccount(user=user1,
-                                name="account12",
-                                jid="account12@jmc.test.com")
+        account11 = AbstractSMTPAccount(user=user1,
+                                        name="account11",
+                                        jid="account11@jmc.test.com")
+        account12 = AbstractSMTPAccount(user=user1,
+                                        name="account12",
+                                        jid="account12@jmc.test.com")
         (name, field_type, field_options, post_func, default_func) = \
-            SMTPAccount.get_register_fields()[7]
+            AbstractSMTPAccount.get_register_fields()[0]
         value = post_func("False", None, "user1@test.com")
         self.assertTrue(value)
-        model.db_disconnect()
 
     def test_default_account_post_func_true(self):
-        model.db_connect()
         user1 = User(jid="user1@test.com")
-        account11 = SMTPAccount(user=user1,
-                                name="account11",
-                                jid="account11@jmc.test.com")
-        account12 = SMTPAccount(user=user1,
-                                name="account12",
-                                jid="account12@jmc.test.com")
+        account11 = AbstractSMTPAccount(user=user1,
+                                        name="account11",
+                                        jid="account11@jmc.test.com")
+        account12 = AbstractSMTPAccount(user=user1,
+                                        name="account12",
+                                        jid="account12@jmc.test.com")
         account12.default_account = True
         (name, field_type, field_options, post_func, default_func) = \
-            SMTPAccount.get_register_fields()[7]
+            AbstractSMTPAccount.get_register_fields()[0]
         value = post_func("True", None, "user1@test.com")
         self.assertTrue(value)
         self.assertFalse(account12.default_account)
-        model.db_disconnect()
 
     def test_default_account_post_func_false(self):
-        model.db_connect()
         user1 = User(jid="user1@test.com")
-        account11 = SMTPAccount(user=user1,
-                                name="account11",
-                                jid="account11@jmc.test.com")
-        account12 = SMTPAccount(user=user1,
-                                name="account12",
-                                jid="account12@jmc.test.com")
+        account11 = AbstractSMTPAccount(user=user1,
+                                        name="account11",
+                                        jid="account11@jmc.test.com")
+        account12 = AbstractSMTPAccount(user=user1,
+                                        name="account12",
+                                        jid="account12@jmc.test.com")
         account12.default_account = True
         (name, field_type, field_options, post_func, default_func) = \
-            SMTPAccount.get_register_fields()[7]
+            AbstractSMTPAccount.get_register_fields()[0]
         value = post_func("False", None, "user1@test.com")
         self.assertFalse(value)
         self.assertTrue(account12.default_account)
-        model.db_disconnect()
 
     def test_create_email(self):
-        model.db_connect()
-        account11 = SMTPAccount(user=User(jid="user1@test.com"),
-                                name="account11",
-                                jid="account11@jmc.test.com")
-        model.db_disconnect()
+        account11 = AbstractSMTPAccount(user=User(jid="user1@test.com"),
+                                        name="account11",
+                                        jid="account11@jmc.test.com")
         email = account11.create_email("from@test.com",
                                        "to@test.com",
                                        "subject",
@@ -881,11 +872,9 @@ class SMTPAccount_TestCase(Account_TestCase):
         self.assertEqual(email.get_payload(), "body")
 
     def test_create_email_other_headers(self):
-        model.db_connect()
-        account11 = SMTPAccount(user=User(jid="user1@test.com"),
-                                name="account11",
-                                jid="account11@jmc.test.com")
-        model.db_disconnect()
+        account11 = AbstractSMTPAccount(user=User(jid="user1@test.com"),
+                                        name="account11",
+                                        jid="account11@jmc.test.com")
         email = account11.create_email("from@test.com",
                                        "to@test.com",
                                        "subject",
@@ -899,6 +888,13 @@ class SMTPAccount_TestCase(Account_TestCase):
         self.assertEqual(email['Cc'], "cc@test.com")
         self.assertEqual(email.get_payload(), "body")
 
+class SMTPAccount_TestCase(Account_TestCase):
+    def setUp(self):
+        JCLTestCase.setUp(self, tables=[Account, ExampleAccount, User,
+                                        GlobalSMTPAccount,
+                                        AbstractSMTPAccount, SMTPAccount])
+        self.account_class = SMTPAccount
+
     def make_test(self, responses=None, queries=None, core=None):
         def inner():
             self.server = server.DummyServer("localhost", 1025)
@@ -1100,6 +1096,7 @@ def suite():
     suite.addTest(unittest.makeSuite(MailAccount_TestCase, 'test'))
     suite.addTest(unittest.makeSuite(POP3Account_TestCase, 'test'))
     suite.addTest(unittest.makeSuite(IMAPAccount_TestCase, 'test'))
+    suite.addTest(unittest.makeSuite(AbstractSMTPAccount_TestCase, 'test'))
     suite.addTest(unittest.makeSuite(SMTPAccount_TestCase, 'test'))
     return suite
 
diff --git a/src/jmc/runner.py b/src/jmc/runner.py
index bdc69d6..e900547 100644
--- a/src/jmc/runner.py
+++ b/src/jmc/runner.py
@@ -3,18 +3,18 @@
 ## Login : David Rousselie <dax@happycoders.org>
 ## Started on  Thu May 17 21:58:32 2007 David Rousselie
 ## $Id$
-## 
+##
 ## Copyright (C) 2007 David Rousselie
 ## This program is free software; you can redistribute it and/or modify
 ## it under the terms of the GNU General Public License as published by
 ## the Free Software Foundation; either version 2 of the License, or
 ## (at your option) any later version.
-## 
+##
 ## This program is distributed in the hope that it will be useful,
 ## but WITHOUT ANY WARRANTY; without even the implied warranty of
 ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 ## GNU General Public License for more details.
-## 
+##
 ## You should have received a copy of the GNU General Public License
 ## along with this program; if not, write to the Free Software
 ## Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
@@ -22,10 +22,14 @@
 
 from jcl.runner import JCLRunner
 
-from jmc.model.account import MailAccount, IMAPAccount, POP3Account, SMTPAccount
+import jmc.model.account as account
+from jmc.model.account import MailAccount, IMAPAccount, POP3Account, \
+    AbstractSMTPAccount, GlobalSMTPAccount, SMTPAccount
 from jmc.jabber.component import MailComponent
 from jmc.lang import Lang
 
+from sqlobject import *
+
 class JMCRunner(JCLRunner):
 
     def __init__(self, component_name, component_version):
@@ -34,12 +38,49 @@ class JMCRunner(JCLRunner):
         # define new options
         self.check_interval = 1
         self.mail_default_encoding = "iso-8859-1"
+        self.smtp_default_login = None
+        self.smtp_default_password = None
+        self.smtp_default_host = None
+        self.smtp_default_port = 0
+        self.smtp_default_tls = False
+        self.smtp_default_label = None
+        self.enable_smtp_default_account = False
         self.options += [("i:", "check-interval=", "jmc",
-                          " INTERVAL\t\t\tInterval unit in minute between mail checks",
-                          lambda arg: setattr(self, "check_interval", int(arg))),
+                          " INTERVAL\t\t\tInterval unit in minutes between mail checks",
+                          lambda arg: self.set_attr("check_interval",
+                                                    int(arg))),
                          ("e:", "mail-default-encoding=", "jmc",
                           " ENCODING\t\tDefault encoding of the component",
-                          lambda arg: setattr(self, "mail_default_encoding", arg))]
+                          lambda arg: self.set_attr("mail_default_encoding",
+                                                    arg)),
+                         ("g:", "smtp-default-login=", "smtp",
+                          " LOGIN\t\t\tDefault SMTP login",
+                          lambda arg: self.set_attr("smtp_default_login", arg)),
+                         ("a:", "smtp-default-password=", "smtp",
+                          " PASSWORD\t\tDefault SMTP password",
+                          lambda arg: self.set_attr("smtp_default_password",
+                                                    arg)),
+                         ("t:", "smtp-default-host=", "smtp",
+                          " HOST\t\t\tDefault SMTP host",
+                          lambda arg: self.set_attr("smtp_default_host", arg)),
+                         ("r:", "smtp-default-port=", "smtp",
+                          " PORT\t\t\tDefault SMTP port",
+                          lambda arg: self.set_attr("smtp_default_port",
+                                                    int(arg))),
+                         ("m:", "smtp-default-tls=", "smtp",
+                          " True/False\t\tDefault SMTP TLS connexion",
+                          lambda arg: self.set_attr("smtp_default_tls",
+                                                    arg.lower() == "true" \
+                                                        or arg == "1")),
+                         ("n:", "enable-smtp-default-account=", "smtp",
+                          " True/False\t\tEnable default SMTP connexion",
+                          lambda arg: self.set_attr("enable_smtp_default_account",
+                                                    arg.lower() == "true" \
+                                                        or arg == "1")),
+                         ("b:", "smtp-default-label=", "smtp",
+                          "\t\t\tDefault SMTP account label",
+                          lambda arg: self.set_attr("smtp_default_label",
+                                                    arg))]
         # override JCL default
         self.service_jid = "jmc.localhost"
         self.db_url = "sqlite:///var/spool/jabber/jmc.db"
@@ -51,8 +92,26 @@ class JMCRunner(JCLRunner):
         MailAccount.createTable(ifNotExists=True)
         IMAPAccount.createTable(ifNotExists=True)
         POP3Account.createTable(ifNotExists=True)
+        AbstractSMTPAccount.createTable(ifNotExists=True)
+        GlobalSMTPAccount.createTable(ifNotExists=True)
         SMTPAccount.createTable(ifNotExists=True)
-        
+
+    def setup_smtp_default(self):
+        """Replace default values for GlobalSMTPAccount"""
+        if self.smtp_default_login:
+            account.smtp_default_login = self.smtp_default_login
+        if self.smtp_default_password:
+            account.smtp_default_password = self.smtp_default_password
+        if self.smtp_default_host:
+            account.smtp_default_host = self.smtp_default_host
+        if self.smtp_default_port:
+            account.smtp_default_port = self.smtp_default_port
+        if self.smtp_default_tls:
+            account.smtp_default_tls = self.smtp_default_tls
+        if self.smtp_default_label:
+            Lang().get_default_lang_class().type_globalsmtp_name = \
+                self.smtp_default_label
+
     def run(self):
         def run_func():
             component = MailComponent(jid=self.service_jid,
@@ -62,11 +121,14 @@ class JMCRunner(JCLRunner):
                                       lang=Lang(self.language),
                                       config=self.config,
                                       config_file=self.config_file)
+            if self.enable_smtp_default_account:
+                component.account_manager.account_classes += (GlobalSMTPAccount,)
             MailAccount.default_encoding = self.mail_default_encoding
             component.check_interval = self.check_interval
             component.disco_identity.set_category("gateway")
             component.disco_identity.set_type("smtp")
             return component.run()
+        self.setup_smtp_default()
         self._run(run_func)
 
 def main():
diff --git a/src/jmc/tests/jmc.conf b/src/jmc/tests/jmc.conf
index 0db842c..91ca664 100644
--- a/src/jmc/tests/jmc.conf
+++ b/src/jmc/tests/jmc.conf
@@ -23,4 +23,11 @@ log_file: /tmp/jmc.log
 mail_default_encoding: test_iso-8859-1
 check_interval: 2
 
-
+[smtp]
+smtp_default_login: testlogin
+smtp_default_password: testpassword
+smtp_default_host: testhost
+smtp_default_port: 2525
+smtp_default_tls: True
+smtp_default_label: SMTP Server
+enable_smtp_default_account: True
diff --git a/src/jmc/tests/runner.py b/src/jmc/tests/runner.py
index eb42cdc..a808af5 100644
--- a/src/jmc/tests/runner.py
+++ b/src/jmc/tests/runner.py
@@ -24,14 +24,19 @@ import unittest
 import sys
 import os
 
+from jcl.tests import JCLTestCase
 from jcl.tests.runner import JCLRunner_TestCase
 
 import jcl.model as model
 from jcl.model.account import Account, PresenceAccount, User, LegacyJID
 
 import jmc
+from jmc.lang import Lang
 from jmc.runner import JMCRunner
-from jmc.model.account import MailAccount, IMAPAccount, POP3Account, SMTPAccount
+from jmc.jabber.component import MailComponent
+import jmc.model.account as account
+from jmc.model.account import MailAccount, IMAPAccount, POP3Account, \
+    AbstractSMTPAccount, GlobalSMTPAccount, SMTPAccount
 
 if sys.platform == "win32":
     DB_PATH = "/c|/temp/test.db"
@@ -39,13 +44,29 @@ else:
     DB_PATH = "/tmp/test.db"
 DB_URL = "sqlite://" + DB_PATH# + "?debug=1&debugThreading=1"
 
-class JMCRunner_TestCase(JCLRunner_TestCase):
+class JMCRunner_TestCase(JCLRunner_TestCase, JCLTestCase):
     def setUp(self):
+        JCLTestCase.setUp(self, tables=[Account, PresenceAccount, User,
+                                        GlobalSMTPAccount, AbstractSMTPAccount])
         self.runner = JMCRunner("Jabber Mail Component", jmc.version)
+        self.smtp_default_login = account.smtp_default_login
+        self.smtp_default_password = account.smtp_default_password
+        self.smtp_default_host = account.smtp_default_host
+        self.smtp_default_port = account.smtp_default_port
+        self.smtp_default_tls = account.smtp_default_tls
+        self.mail_default_encoding = MailAccount.default_encoding
+        self.type_globalsmtp_name = Lang.en.type_globalsmtp_name
 
     def tearDown(self):
         self.runner = None
         sys.argv = [""]
+        account.smtp_default_login = self.smtp_default_login
+        account.smtp_default_password = self.smtp_default_password
+        account.smtp_default_host = self.smtp_default_host
+        account.smtp_default_port = self.smtp_default_port
+        account.smtp_default_tls = self.smtp_default_tls
+        MailAccount.default_encoding = self.mail_default_encoding
+        Lang.en.type_globalsmtp_name = self.type_globalsmtp_name
 
     def test_configure_default(self):
         self.runner.configure()
@@ -60,6 +81,24 @@ class JMCRunner_TestCase(JCLRunner_TestCase):
         self.assertFalse(self.runner.debug)
         self.assertEquals(self.runner.mail_default_encoding, "iso-8859-1")
         self.assertEquals(self.runner.check_interval, 1)
+        self.assertEquals(self.runner.smtp_default_login, None)
+        self.assertEquals(self.runner.smtp_default_password, None)
+        self.assertEquals(self.runner.smtp_default_host, None)
+        self.assertEquals(self.runner.smtp_default_port, 0)
+        self.assertEquals(self.runner.smtp_default_tls, False)
+        self.assertEquals(self.runner.enable_smtp_default_account, False)
+        self.assertEquals(self.runner.smtp_default_label, None)
+        self.runner.setup_smtp_default()
+        self.assertEquals(Lang.en.type_globalsmtp_name,
+                          "Default SMTP Server")
+        _account = GlobalSMTPAccount(user=User(jid="user1@test.com"),
+                                     name="account1",
+                                     jid="account1@jmc.test.com")
+        self.assertEquals(_account.login, '')
+        self.assertEquals(_account.password, '')
+        self.assertEquals(_account.host, 'localhost')
+        self.assertEquals(_account.port, 25)
+        self.assertEquals(_account.tls, False)
 
     def test_configure_configfile(self):
         self.runner.config_file = "src/jmc/tests/jmc.conf"
@@ -72,8 +111,26 @@ class JMCRunner_TestCase(JCLRunner_TestCase):
         self.assertEquals(self.runner.db_url, "test_sqlite://root@localhost/var/spool/jabber/test_jmc.db")
         self.assertEquals(self.runner.pid_file, "/var/run/jabber/test_jmc.pid")
         self.assertFalse(self.runner.debug)
-        self.assertEquals(self.runner.mail_default_encoding, "test_iso-8859-1")
         self.assertEquals(self.runner.check_interval, 2)
+        self.assertEquals(self.runner.mail_default_encoding, "test_iso-8859-1")
+        self.assertEquals(self.runner.smtp_default_login, "testlogin")
+        self.assertEquals(self.runner.smtp_default_password, "testpassword")
+        self.assertEquals(self.runner.smtp_default_host, "testhost")
+        self.assertEquals(self.runner.smtp_default_port, 2525)
+        self.assertEquals(self.runner.smtp_default_tls, True)
+        self.assertEquals(self.runner.enable_smtp_default_account, True)
+        self.assertEquals(self.runner.smtp_default_label, "SMTP Server")
+        self.runner.setup_smtp_default()
+        self.assertEquals(Lang.en.type_globalsmtp_name,
+                          "SMTP Server")
+        _account = GlobalSMTPAccount(user=User(jid="user1@test.com"),
+                                     name="account1",
+                                     jid="account1@jmc.test.com")
+        self.assertEquals(_account.login, 'testlogin')
+        self.assertEquals(_account.password, 'testpassword')
+        self.assertEquals(_account.host, 'testhost')
+        self.assertEquals(_account.port, 2525)
+        self.assertEquals(_account.tls, True)
 
     def test_configure_uncomplete_configfile(self):
         self.runner.config_file = "src/jmc/tests/uncomplete_jmc.conf"
@@ -86,18 +143,45 @@ class JMCRunner_TestCase(JCLRunner_TestCase):
         self.assertEquals(self.runner.db_url, "test_sqlite://root@localhost/var/spool/jabber/test_jmc.db")
         self.assertEquals(self.runner.pid_file, "/var/run/jabber/test_jmc.pid")
         self.assertFalse(self.runner.debug)
+        self.assertEquals(self.runner.check_interval, 2)
+        self.assertEquals(self.runner.mail_default_encoding, "test_iso-8859-1")
+        self.assertEquals(self.runner.smtp_default_login, None)
+        self.assertEquals(self.runner.smtp_default_password, None)
+        self.assertEquals(self.runner.smtp_default_host, None)
+        self.assertEquals(self.runner.smtp_default_port, 0)
+        self.assertEquals(self.runner.smtp_default_tls, False)
+        self.assertEquals(self.runner.enable_smtp_default_account, False)
+        self.assertEquals(self.runner.smtp_default_label, None)
+        self.runner.setup_smtp_default()
+        self.assertEquals(Lang.en.type_globalsmtp_name,
+                          "Default SMTP Server")
+        _account = GlobalSMTPAccount(user=User(jid="user1@test.com"),
+                                     name="account1",
+                                     jid="account1@jmc.test.com")
+        self.assertEquals(_account.login, '')
+        self.assertEquals(_account.password, '')
+        self.assertEquals(_account.host, 'localhost')
+        self.assertEquals(_account.port, 25)
+        self.assertEquals(_account.tls, False)
 
     def test_configure_commandline_shortopt(self):
-        sys.argv = ["", "-c", "src/jmc/tests/jmc.conf", \
-                    "-S", "test2_localhost", \
-                    "-P", "43", \
-                    "-s", "test2_secret", \
-                    "-j", "test2_jmc.localhost", \
-                    "-l", "test2_en", \
-                    "-u", "sqlite:///tmp/test_jmc.db", \
-                    "-p", "/tmp/test_jmc.pid", \
-                    "-e", "test2_iso-8859-1", \
-                    "-i", "3"]
+        sys.argv = ["", "-c", "src/jmc/tests/jmc.conf",
+                    "-S", "test2_localhost",
+                    "-P", "43",
+                    "-s", "test2_secret",
+                    "-j", "test2_jmc.localhost",
+                    "-l", "test2_en",
+                    "-u", "sqlite:///tmp/test_jmc.db",
+                    "-p", "/tmp/test_jmc.pid",
+                    "-e", "test2_iso-8859-1",
+                    "-i", "3",
+                    "-g", "testlogin",
+                    "-a", "testpassword",
+                    "-t", "testhost",
+                    "-r", "2525",
+                    "-m", "True",
+                    "-n", "True",
+                    "-b", "My Global SMTP server"]
         self.runner.configure()
         self.assertEquals(self.runner.server, "test2_localhost")
         self.assertEquals(self.runner.port, 43)
@@ -109,18 +193,43 @@ class JMCRunner_TestCase(JCLRunner_TestCase):
         self.assertFalse(self.runner.debug)
         self.assertEquals(self.runner.mail_default_encoding, "test2_iso-8859-1")
         self.assertEquals(self.runner.check_interval, 3)
+        self.assertEquals(self.runner.smtp_default_login, "testlogin")
+        self.assertEquals(self.runner.smtp_default_password, "testpassword")
+        self.assertEquals(self.runner.smtp_default_host, "testhost")
+        self.assertEquals(self.runner.smtp_default_port, 2525)
+        self.assertEquals(self.runner.smtp_default_tls, True)
+        self.assertEquals(self.runner.enable_smtp_default_account, True)
+        self.assertEquals(self.runner.smtp_default_label, "My Global SMTP server")
+        self.runner.setup_smtp_default()
+        self.assertEquals(Lang.en.type_globalsmtp_name,
+                          "My Global SMTP server")
+        _account = GlobalSMTPAccount(user=User(jid="user1@test.com"),
+                                     name="account1",
+                                     jid="account1@jmc.test.com")
+        self.assertEquals(_account.login, 'testlogin')
+        self.assertEquals(_account.password, 'testpassword')
+        self.assertEquals(_account.host, 'testhost')
+        self.assertEquals(_account.port, 2525)
+        self.assertEquals(_account.tls, True)
 
     def test_configure_commandline_longopt(self):
-        sys.argv = ["", "--config-file", "src/jmc/tests/jmc.conf", \
-                    "--server", "test2_localhost", \
-                    "--port", "43", \
-                    "--secret", "test2_secret", \
-                    "--service-jid", "test2_jmc.localhost", \
-                    "--language", "test2_en", \
-                    "--db-url", "sqlite:///tmp/test_jmc.db", \
-                    "--pid-file", "/tmp/test_jmc.pid", \
-                    "--mail-default-encoding", "test2_iso-8859-1", \
-                    "--check-interval", "4"]
+        sys.argv = ["", "--config-file", "src/jmc/tests/jmc.conf",
+                    "--server", "test2_localhost",
+                    "--port", "43",
+                    "--secret", "test2_secret",
+                    "--service-jid", "test2_jmc.localhost",
+                    "--language", "test2_en",
+                    "--db-url", "sqlite:///tmp/test_jmc.db",
+                    "--pid-file", "/tmp/test_jmc.pid",
+                    "--mail-default-encoding", "test2_iso-8859-1",
+                    "--check-interval", "4",
+                    "--smtp-default-login", "testlogin",
+                    "--smtp-default-password", "testpassword",
+                    "--smtp-default-host", "testhost",
+                    "--smtp-default-port", "2525",
+                    "--smtp-default-tls", "True",
+                    "--enable-smtp-default-account", "True",
+                    "--smtp-default-label", "My Global SMTP server"]
         self.runner.configure()
         self.assertEquals(self.runner.server, "test2_localhost")
         self.assertEquals(self.runner.port, 43)
@@ -132,6 +241,24 @@ class JMCRunner_TestCase(JCLRunner_TestCase):
         self.assertFalse(self.runner.debug)
         self.assertEquals(self.runner.mail_default_encoding, "test2_iso-8859-1")
         self.assertEquals(self.runner.check_interval, 4)
+        self.assertEquals(self.runner.smtp_default_login, "testlogin")
+        self.assertEquals(self.runner.smtp_default_password, "testpassword")
+        self.assertEquals(self.runner.smtp_default_host, "testhost")
+        self.assertEquals(self.runner.smtp_default_port, 2525)
+        self.assertEquals(self.runner.smtp_default_tls, True)
+        self.assertEquals(self.runner.enable_smtp_default_account, True)
+        self.assertEquals(self.runner.smtp_default_label, "My Global SMTP server")
+        self.runner.setup_smtp_default()
+        self.assertEquals(Lang.en.type_globalsmtp_name,
+                          "My Global SMTP server")
+        _account = GlobalSMTPAccount(user=User(jid="user1@test.com"),
+                                     name="account1",
+                                     jid="account1@jmc.test.com")
+        self.assertEquals(_account.login, 'testlogin')
+        self.assertEquals(_account.password, 'testpassword')
+        self.assertEquals(_account.host, 'testhost')
+        self.assertEquals(_account.port, 2525)
+        self.assertEquals(_account.tls, True)
 
     def test__run(self):
         self.runner.pid_file = "/tmp/jmc.pid"
@@ -154,6 +281,47 @@ class JMCRunner_TestCase(JCLRunner_TestCase):
         os.unlink(DB_PATH)
         self.assertFalse(os.access("/tmp/jmc.pid", os.F_OK))
 
+    def test_run_without_smtp_default_account(self):
+        """ """
+        def run_func(mail_component_self):
+            """ """
+            self.assertEquals(mail_component_self.account_manager.account_classes,
+                              (IMAPAccount, POP3Account, SMTPAccount))
+            return False
+
+        self.runner.enable_smtp_default_account = False
+        self.runner.pid_file = "/tmp/jmc.pid"
+        self.runner.db_url = DB_URL
+        self.runner.config = None
+        old_run_func = MailComponent.run
+        MailComponent.run = run_func
+        try:
+            self.runner.run()
+        finally:
+            MailComponent.run = old_run_func
+        self.assertFalse(os.access("/tmp/jmc.pid", os.F_OK))
+
+    def test_run_with_smtp_default_account(self):
+        """ """
+        def run_func(mail_component_self):
+            """ """
+            self.assertEquals(mail_component_self.account_manager.account_classes,
+                              (IMAPAccount, POP3Account, SMTPAccount,
+                               GlobalSMTPAccount))
+            return False
+
+        self.runner.enable_smtp_default_account = True
+        self.runner.pid_file = "/tmp/jmc.pid"
+        self.runner.db_url = DB_URL
+        self.runner.config = None
+        old_run_func = MailComponent.run
+        MailComponent.run = run_func
+        try:
+            self.runner.run()
+        finally:
+            MailComponent.run = old_run_func
+        self.assertFalse(os.access("/tmp/jmc.pid", os.F_OK))
+
 def suite():
     test_suite = unittest.TestSuite()
     test_suite.addTest(unittest.makeSuite(JMCRunner_TestCase, 'test'))