david/jmc
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Add default SMTP server configuration

Browse Source 
darcs-hash:20080520061718-86b55-63ae914b5a132cd49215216ae73ca10c0cef7748.gz
This commit is contained in:
David Rousselie
2008-05-20 08:17:18 +02:00
parent 8a2fb397b9
commit dcb87e610e
11 changed files with 467 additions and 192 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/jmc/jabber/component.py
View File

@@ -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, \

9
src/jmc/jabber/message.py
View File

@@ -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):
@@ -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):
@@ -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)]

9
src/jmc/jabber/tests/command.py
View File

@@ -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,

14
src/jmc/jabber/tests/component.py
View File

@@ -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()

7
src/jmc/jabber/tests/message.py
View File

@@ -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
@@ -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):

1
src/jmc/lang.py
View File

@@ -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" \

209
src/jmc/model/account.py
View File

@@ -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,82 +700,7 @@ class SMTPAccount(Account):
"""SMTPAccount init
Initialize class attributes"""
Account._init(self, *args, **kw)
self.__logger = logging.getLogger("jmc.model.account.SMTPAccount")
def _get_default_port(cls):
"""Return default SMTP server port"""
return 25
get_default_port = classmethod(_get_default_port)
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 default_account_default_func(bare_from_jid):
accounts = account.get_accounts(bare_from_jid, SMTPAccount,
(SMTPAccount.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))
already_default_account = (accounts.count() != 0)
if isinstance(value, str):
value = value.lower()
bool_value = (value == "true" or value == "1")
else:
bool_value = value
if bool_value:
if already_default_account:
for _account in accounts:
_account.default_account = False
return True
else:
if not already_default_account:
return True
else:
return False
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_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)]
get_register_fields = classmethod(_get_register_fields)
get_default_status_msg = _get_default_status_msg
self.__logger = logging.getLogger("jmc.model.account.AbstractSMTPAccount")
def get_type(self):
if self.tls:
@@ -806,6 +722,82 @@ class SMTPAccount(Account):
_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, 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, AbstractSMTPAccount,
(AbstractSMTPAccount.q.default_account == True))
already_default_account = (accounts.count() != 0)
if isinstance(value, str):
value = value.lower()
bool_value = (value == "true" or value == "1")
else:
bool_value = value
if bool_value:
if already_default_account:
for _account in accounts:
_account.default_account = False
return True
else:
if not already_default_account:
return True
else:
return False
if real_class is None:
real_class = cls
return Account.get_register_fields(real_class) + \
[("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: "")]
get_register_fields = classmethod(_get_register_fields)
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 _init(self, *args, **kw):
"""SMTPAccount init
Initialize class attributes"""
AbstractSMTPAccount._init(self, *args, **kw)
self.__logger = logging.getLogger("jmc.model.account.GlobalSMTPAccount")
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)
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):
(code, resp) = connection.helo()
@@ -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)

97
src/jmc/model/tests/account.py
View File

@@ -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

70
src/jmc/runner.py
View File

@@ -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():

9
src/jmc/tests/jmc.conf
View File

@@ -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

214
src/jmc/tests/runner.py
View File

@@ -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'))