def test_send_email_esmtp_no_auth(self):
model.db_connect()
smtp_account = SMTPAccount(user=User(jid="*****@*****.**"), name="account11", jid="*****@*****.**")
smtp_account.host = "localhost"
smtp_account.port = 1025
model.db_disconnect()
email = smtp_account.create_email("*****@*****.**", "*****@*****.**", "subject", "body")
test_func = self.make_test(
[
"220 localhost ESMTP\r\n",
"250-localhost Hello 127.0.0.1\r\n" + "250-SIZE 52428800\r\n" + "250-PIPELINING\r\n" + "250 HELP\r\n",
"250 OK\r\n",
"250 Accepted\r\n",
"354 Enter message\r\n",
None,
None,
None,
None,
None,
None,
None,
None,
"250 OK\r\n",
],
[
"ehlo .*\r\n",
"mail FROM:<" + str(email["From"]) + ">.*",
"rcpt TO:<" + str(email["To"]) + ">\r\n",
"data\r\n",
]
+ email.as_string().split("\n")
+ [".\r\n"],
lambda self: smtp_account.send_email(email),
)
test_func()
def get_all_accounts_count(account_class=Account, filter=None):
model.db_connect()
if filter is None:
accounts_count = account_class.select().count()
else:
accounts_count = account_class.select(filter).count()
return accounts_count
def get_user(bare_from_jid, user_class=User):
result = None
model.db_connect()
users = user_class.select(User.q.jid == bare_from_jid)
if users.count() > 0:
result = users[0]
return result
def test_send_closed_connection(self):
self.comp.stream = None
model.db_connect()
account11 = Account(user=User(jid="*****@*****.**"),
name="account11",
jid="*****@*****.**")
self.sender.send(account11, ("subject", "Body message"))
def get_legacy_jids(bare_to_jid):
model.db_connect()
legacy_jids = LegacyJID.select(\
AND(AND(LegacyJID.q.accountID == Account.q.id,
Account.q.userID == User.q.id),
User.q.jid == bare_to_jid))
return legacy_jids
def inner():
self.server = server.DummyServer("localhost", 1143)
thread.start_new_thread(self.server.serve, ())
self.server.responses = [
"* OK [CAPABILITY IMAP4 LOGIN-REFERRALS " + "AUTH=PLAIN]\r\n",
lambda data: "* CAPABILITY IMAP4 "
+ "LOGIN-REFERRALS AUTH=PLAIN\r\n"
+ data.split()[0]
+ " OK CAPABILITY completed\r\n",
lambda data: data.split()[0] + " OK LOGIN completed\r\n",
]
if responses:
self.server.responses += responses
self.server.queries = ["^[^ ]* CAPABILITY", '^[^ ]* LOGIN login "pass"']
if queries:
self.server.queries += queries
self.server.queries += ["^[^ ]* LOGOUT"]
if not self.imap_account.connected:
self.imap_account.connect()
self.failUnless(self.imap_account.connection, "Cannot establish connection")
if core:
model.db_connect()
core(self)
model.db_disconnect()
if self.imap_account.connected:
self.imap_account.disconnect()
self.failUnless(self.server.verify_queries())
def tearDown(self):
model.db_connect()
MyMockSQLObject.dropTable(ifExists=True)
del TheURIOpener.cachedURIs[self.db_url]
model.hub.threadConnection.close()
model.db_disconnect()
if os.path.exists(self.db_path):
os.unlink(self.db_path)
def test_set_status(self):
model.db_connect()
account11 = Account(user=User(jid="*****@*****.**"),
name="account11",
jid="*****@*****.**")
account11.status = account.OFFLINE
self.assertEquals(account11.status, account.OFFLINE)
model.db_disconnect()
def get_account_filter(filter, account_class=Account):
result = None
model.db_connect()
accounts = account_class.select(filter)
if accounts.count() > 0:
result = accounts[0]
model.db_disconnect()
return result
def setUp(self):
self.db_path = tempfile.mktemp("db", "jcltest", DB_DIR)
if os.path.exists(self.db_path):
os.unlink(self.db_path)
self.db_url = "sqlite://" + self.db_path
model.db_connection_str = self.db_url
model.db_connect()
MyMockSQLObject.createTable(ifNotExists=True)
model.db_disconnect()
def create_account_thread():
for i in xrange(100):
string_attr = "obj2" + str(i)
model.db_connect()
obj = MyMockSQLObject(string_attr=string_attr)
model.db_disconnect()
model.db_connect()
obj2 = MyMockSQLObject.select(MyMockSQLObject.q.string_attr == string_attr)
model.db_disconnect()
self.assertEquals(obj, obj2[0])
def setUp(self, tables=[]):
JCLTestCase.setUp(self, tables=[User, Account, PresenceAccount,
PresenceAccountExample] + tables)
model.db_connect()
self.account = PresenceAccountExample(\
user=User(jid="*****@*****.**"),
name="account11",
jid="*****@*****.**")
model.db_disconnect()
self.account_class = PresenceAccount
def test_send_email_esmtp_auth_method2(self):
model.db_connect()
smtp_account = SMTPAccount(user=User(jid="*****@*****.**"), name="account11", jid="*****@*****.**")
smtp_account.host = "localhost"
smtp_account.port = 1025
smtp_account.login = "******"
smtp_account.password = "******"
model.db_disconnect()
email = smtp_account.create_email("*****@*****.**", "*****@*****.**", "subject", "body")
test_func = self.make_test(
[
"220 localhost ESMTP\r\n",
"250-localhost Hello 127.0.0.1\r\n"
+ "250-SIZE 52428800\r\n"
+ "250-AUTH PLAIN LOGIN CRAM-MD5\r\n"
+ "250-PIPELINING\r\n"
+ "250 HELP\r\n",
"334 ZGF4IDNmNDM2NzY0YzBhNjgyMTQ1MzhhZGNiMjE2YTYxZjRm\r\n",
"535 Incorrect Authentication data\r\n",
"334 asd235r4\r\n",
"235 Authentication succeeded\r\n",
"250 OK\r\n",
"250 Accepted\r\n",
"354 Enter message\r\n",
None,
None,
None,
None,
None,
None,
None,
None,
"250 OK\r\n",
],
[
"ehlo .*\r\n",
"AUTH CRAM-MD5\r\n",
".*\r\n",
"AUTH LOGIN .*\r\n",
".*\r\n",
"mail FROM:<" + str(email["From"]) + ">.*",
"rcpt TO:<" + str(email["To"]) + ">\r\n",
"data\r\n",
]
+ email.as_string().split("\n")
+ [".\r\n"],
lambda self: smtp_account.send_email(email),
)
test_func()
def run_console(self):
"""
Run JCL console. Used to access SQLObject connection
"""
from IPython.Shell import IPShellEmbed
# pre-import jcl.model.account to be used in the shell
import jcl.model.account as account
model.db_connection_str = self.db_url
model.db_connect()
self.setup_db()
ipshell = IPShellEmbed(["-pi1", self.component_short_name + "[\\#]: "],
"Starting " + self.component_name + " v" \
+ self.component_version + " console.",
"Ending " + self.component_name + " v" \
+ self.component_version + " console.")
ipshell()
def inner():
self.server = server.DummyServer("localhost", 1025)
thread.start_new_thread(self.server.serve, ())
self.server.responses = []
if responses:
self.server.responses += responses
self.server.responses += ["221 localhost closing connection\r\n"]
self.server.queries = []
if queries:
self.server.queries += queries
self.server.queries += ["quit\r\n"]
if core:
model.db_connect()
core(self)
model.db_disconnect()
self.failUnless(self.server.verify_queries())
def test_send(self):
self.comp.stream = MockStream()
self.comp.stream_class = MockStream
model.db_connect()
account11 = Account(user=User(jid="*****@*****.**"),
name="account11",
jid="*****@*****.**")
self.sender.send(account11, ("subject", "Body message"))
self.assertEquals(len(self.comp.stream.sent), 1)
message = self.comp.stream.sent[0]
self.assertEquals(message.get_from(), account11.jid)
self.assertEquals(message.get_to(), account11.user.jid)
self.assertEquals(message.get_subject(), "subject")
self.assertEquals(message.get_body(), "Body message")
self.assertEquals(message.get_type(), self.message_type)
model.db_disconnect()
def test_set_status_live_password(self):
model.db_connect()
account11 = ExampleAccount(user=User(jid="*****@*****.**"),
name="account11",
jid="*****@*****.**",
login="******",
password="******",
store_password=False,
test_enum="choice3",
test_int=21)
account11.waiting_password_reply = True
account11.status = account.OFFLINE
self.assertEquals(account11.status, account.OFFLINE)
self.assertEquals(account11.waiting_password_reply, False)
self.assertEquals(account11.password, None)
model.db_disconnect()
def test_filter_not_password_account(self):
model.db_connect()
user1 = User(jid="*****@*****.**")
account11 = Account(user=user1,
name="account11",
jid="*****@*****.**")
account12 = Account(user=user1,
name="account12",
jid="*****@*****.**")
message = Message(from_jid="*****@*****.**",
to_jid="*****@*****.**",
subject="[PASSWORD]",
body="secret")
_account = self.handler.filter(message, None)
self.assertEquals(_account, None)
model.db_disconnect()
def test__run(self):
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
def do_nothing():
return (False, 0)
self.runner._run(do_nothing)
model.db_connect()
# dropTable should succeed because tables should exist
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_filter_not_good_message(self):
model.db_connect()
user1 = User(jid="*****@*****.**")
account11 = ExampleAccount(user=user1,
name="account11",
jid="*****@*****.**")
account11.waiting_password_reply = True
account12 = ExampleAccount(user=user1,
name="account12",
jid="*****@*****.**")
message = Message(from_jid="*****@*****.**",
to_jid="*****@*****.**",
subject="[WRONG MESSAGE]",
body="secret")
_account = self.handler.filter(message, None)
self.assertEquals(_account, None)
model.db_disconnect()
def test_filter_waiting_password(self):
model.db_connect()
user1 = User(jid="*****@*****.**")
account11 = ExampleAccount(user=user1,
name="account11",
jid="*****@*****.**")
account11.waiting_password_reply = True
account12 = ExampleAccount(user=user1,
name="account12",
jid="*****@*****.**")
message = Message(from_jid="[email protected]/resource",
to_jid="*****@*****.**",
subject="[PASSWORD]",
body="secret")
_account = self.handler.filter(message, None)
self.assertEquals(_account.name, "account11")
model.db_disconnect()
def test_handle(self):
model.db_connect()
user1 = User(jid="*****@*****.**")
account11 = ExampleAccount(user=user1,
name="account11",
jid="*****@*****.**")
account12 = ExampleAccount(user=user1,
name="account12",
jid="*****@*****.**")
message = Message(from_jid="[email protected]/resource",
to_jid="*****@*****.**",
subject="[PASSWORD]",
body="secret")
messages = self.handler.handle(message, Lang.en, account11)
self.assertEquals(len(messages), 1)
self.assertEquals(account11.password, "secret")
model.db_disconnect()
def inner(self):
self.server = server.DummyServer("localhost", 1110)
thread.start_new_thread(self.server.serve, ())
self.server.responses = ["+OK connected\r\n", "+OK name is a valid mailbox\r\n", "+OK pass\r\n"]
if responses:
self.server.responses += responses
self.server.queries = ["USER login\r\n", "PASS pass\r\n"]
if queries:
self.server.queries += queries
self.server.queries += ["QUIT\r\n"]
self.pop3_account.connect()
self.failUnless(self.pop3_account.connection, "Cannot establish connection")
if core:
model.db_connect()
core(self)
model.db_disconnect()
self.pop3_account.disconnect()
self.failUnless(self.server.verify_queries(), "Sended queries does not match expected queries.")
def test__run(self):
self.runner.pid_file = "/tmp/jmc.pid"
self.runner.db_url = self.db_url
def do_nothing():
return (False, 0)
self.runner._run(do_nothing)
model.db_connection_str = self.runner.db_url
model.db_connect()
# dropTable should succeed because tables should exist
Account.dropTable()
PresenceAccount.dropTable()
User.dropTable()
LegacyJID.dropTable()
MailAccount.dropTable()
IMAPAccount.dropTable()
POP3Account.dropTable()
SMTPAccount.dropTable()
model.db_disconnect()
self.assertFalse(os.access("/tmp/jmc.pid", os.F_OK))
def test_get_register_fields(self):
"""
Check if post functions and default functions execute correctly.
To be validated this test only need to be executed without any
exception.
"""
model.db_connect()
for (field_name,
field_type,
field_options,
field_post_func,
field_default_func) in self.account_class.get_register_fields():
if field_name is not None:
try:
field_post_func(field_default_func("*****@*****.**"),
field_default_func, "*****@*****.**")
except FieldError, error:
# this type of error is OK
pass
def _run(self, run_func):
if self.console:
self.run_console()
else:
try:
self.setup_pidfile()
model.db_connection_str = self.db_url
model.db_connect()
self.setup_db()
model.db_disconnect()
self.logger.debug(self.component_name + " v" +
self.component_version + " is starting ...")
restart = True
while restart:
(restart, time_to_wait) = run_func()
self.wait_event.wait(time_to_wait)
self.logger.debug(self.component_name + " is exiting")
finally:
if os.path.exists(self.pid_file):
os.remove(self.pid_file)
def account_get_register(self, info_query, name, from_jid, account_type, lang_class):
"""
Handle get_register on an IMAP account.
Return a preinitialized form.
account_type contains 'account_type + imap_dir'
"""
splitted_node = account_type.split("/")
splitted_node_len = len(splitted_node)
if splitted_node_len == 1 or splitted_node[0] != "IMAP":
return AccountManager.account_get_register(self, info_query, name, from_jid, account_type, lang_class)
else:
info_query = info_query.make_result_response()
model.db_connect()
imap_dir = "/".join(splitted_node[1:])
bare_from_jid = from_jid.bare()
_account = account.get_account_filter(
AND(
AND(User.q.jid == unicode(bare_from_jid), Account.q.userID == User.q.id),
IMAPAccount.q.mailbox == imap_dir,
),
account_class=IMAPAccount,
)
query = info_query.new_query("jabber:iq:register")
if _account is not None:
# update account
result = self.generate_registration_form_init(lang_class, _account)
else:
_account = account.get_account(bare_from_jid, name, IMAPAccount)
if _account is not None:
# create new account based on current one
result = self.generate_registration_form_init(lang_class, _account)
result["name"].value = None
result["name"].type = "text-single"
result["mailbox"].value = imap_dir.replace("/", _account.delimiter)
else:
# create new account from scratch
result = self.generate_registration_form(lang_class, IMAPAccount, bare_from_jid)
result["mailbox"].value = imap_dir
result.as_xml(query)
return [info_query]
def test_multiple_db_connection(self):
def create_account_thread():
for i in xrange(100):
string_attr = "obj2" + str(i)
model.db_connect()
obj = MyMockSQLObject(string_attr=string_attr)
model.db_disconnect()
model.db_connect()
obj2 = MyMockSQLObject.select(MyMockSQLObject.q.string_attr == string_attr)
model.db_disconnect()
self.assertEquals(obj, obj2[0])
timer_thread = threading.Thread(target=create_account_thread,
name="CreateAccountThread")
timer_thread.start()
for i in xrange(100):
string_attr = "obj1" + str(i)
model.db_connect()
obj = MyMockSQLObject(string_attr=string_attr)
model.db_disconnect()
model.db_connect()
obj2 = MyMockSQLObject.select(MyMockSQLObject.q.string_attr == string_attr)
model.db_disconnect()
self.assertEquals(obj, obj2[0])
timer_thread.join(2)
threads = threading.enumerate()
self.assertEquals(len(threads), 1)
model.db_connect()
objs = MyMockSQLObject.select()
self.assertEquals(objs.count(), 200)
model.db_disconnect()
def test__run_restart(self):
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.i = 0
def restart(self):
self.i += 1
yield (True, 0)
self.i += 1
yield (False, 0)
self.i += 1
restart_generator = restart(self)
self.runner._run(lambda : restart_generator.next())
model.db_connect()
# dropTable should succeed because tables should exist
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))
self.assertEquals(self.i, 2)
def test_handle_tick(self):
class AccountFeeder(Feeder):
def feed(self, _account):
return [("Simple Message for account " + _account.name,
"user_jid: " + _account.user.jid),
("Simple Message for account " + _account.name,
"jid: " + _account.jid)]
self.comp.stream = MockStream()
self.comp.stream_class = MockStream
model.db_connect()
user1 = User(jid="*****@*****.**")
account11 = Account(user=user1,
name="account11",
jid="*****@*****.**")
account12 = Account(user=user1,
name="account12",
jid="*****@*****.**")
account2 = Account(user=User(jid="*****@*****.**"),
name="account2",
jid="*****@*****.**")
self.comp.tick_handlers = [FeederHandler(AccountFeeder(self.comp),
MessageSender(self.comp)),
FeederHandler(AccountFeeder(self.comp),
MessageSender(self.comp))]
self.comp.handle_tick()
messages_sent = self.comp.stream.sent
self.assertEquals(len(messages_sent), 12)
self.assertEquals(messages_sent[0].get_from(), "*****@*****.**")
self.assertEquals(messages_sent[0].get_to(), "*****@*****.**")
self.assertEquals(messages_sent[0].get_subject(),
"Simple Message for account account11")
self.assertEquals(messages_sent[0].get_body(),
"user_jid: [email protected]")
self.assertEquals(messages_sent[1].get_from(), "*****@*****.**")
self.assertEquals(messages_sent[1].get_to(), "*****@*****.**")
self.assertEquals(messages_sent[1].get_subject(),
"Simple Message for account account11")
self.assertEquals(messages_sent[1].get_body(),
"jid: [email protected]")
self.assertEquals(messages_sent[2].get_from(), "*****@*****.**")
self.assertEquals(messages_sent[2].get_to(), "*****@*****.**")
self.assertEquals(messages_sent[2].get_subject(),
"Simple Message for account account12")
self.assertEquals(messages_sent[2].get_body(),
"user_jid: [email protected]")
self.assertEquals(messages_sent[3].get_from(), "*****@*****.**")
self.assertEquals(messages_sent[3].get_to(), "*****@*****.**")
self.assertEquals(messages_sent[3].get_subject(),
"Simple Message for account account12")
self.assertEquals(messages_sent[3].get_body(),
"jid: [email protected]")
self.assertEquals(messages_sent[4].get_from(), "*****@*****.**")
self.assertEquals(messages_sent[4].get_to(), "*****@*****.**")
self.assertEquals(messages_sent[4].get_subject(),
"Simple Message for account account2")
self.assertEquals(messages_sent[4].get_body(),
"user_jid: [email protected]")
self.assertEquals(messages_sent[5].get_from(), "*****@*****.**")
self.assertEquals(messages_sent[5].get_to(), "*****@*****.**")
self.assertEquals(messages_sent[5].get_subject(),
"Simple Message for account account2")
self.assertEquals(messages_sent[5].get_body(),
"jid: [email protected]")
self.assertEquals(messages_sent[6].get_from(), "*****@*****.**")
self.assertEquals(messages_sent[6].get_to(), "*****@*****.**")
self.assertEquals(messages_sent[6].get_subject(),
"Simple Message for account account11")
self.assertEquals(messages_sent[6].get_body(),
"user_jid: [email protected]")
self.assertEquals(messages_sent[7].get_from(), "*****@*****.**")
self.assertEquals(messages_sent[7].get_to(), "*****@*****.**")
self.assertEquals(messages_sent[7].get_subject(),
"Simple Message for account account11")
self.assertEquals(messages_sent[7].get_body(),
"jid: [email protected]")
self.assertEquals(messages_sent[8].get_from(), "*****@*****.**")
self.assertEquals(messages_sent[8].get_to(), "*****@*****.**")
self.assertEquals(messages_sent[8].get_subject(),
"Simple Message for account account12")
self.assertEquals(messages_sent[8].get_body(),
"user_jid: [email protected]")
self.assertEquals(messages_sent[9].get_from(), "*****@*****.**")
self.assertEquals(messages_sent[9].get_to(), "*****@*****.**")
self.assertEquals(messages_sent[9].get_subject(),
"Simple Message for account account12")
self.assertEquals(messages_sent[9].get_body(),
"jid: [email protected]")
self.assertEquals(messages_sent[10].get_from(), "*****@*****.**")
self.assertEquals(messages_sent[10].get_to(), "*****@*****.**")
self.assertEquals(messages_sent[10].get_subject(),
"Simple Message for account account2")
self.assertEquals(messages_sent[10].get_body(),
"user_jid: [email protected]")
self.assertEquals(messages_sent[11].get_from(), "*****@*****.**")
self.assertEquals(messages_sent[11].get_to(), "*****@*****.**")
self.assertEquals(messages_sent[11].get_subject(),
"Simple Message for account account2")
self.assertEquals(messages_sent[11].get_body(),
"jid: [email protected]")
