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]")