From a44b18828e47e28a73703acfa7478e97502a220b Mon Sep 17 00:00:00 2001 From: David Rousselie Date: Sun, 22 Jan 2006 13:59:43 +0100 Subject: [PATCH] Component migration to use storage !! Warning !! Not fully tested. darcs-hash:20060122125943-86b55-a0cb0c408b0974b18af8613144bb3a7c3f2288bf.gz --- jabber/component.py | 210 ++++++++++++++++++--------------------- jabber/mailconnection.py | 10 +- jabber/storage.py | 77 +++++++------- run_test.py | 6 +- tests/dummy_server.py | 51 +++++----- tests/test_component.py | 152 ++++++++++++++-------------- tests/test_storage.py | 19 ++-- 7 files changed, 269 insertions(+), 256 deletions(-) diff --git a/jabber/component.py b/jabber/component.py index c9c6650..398d3f4 100644 --- a/jabber/component.py +++ b/jabber/component.py @@ -65,7 +65,6 @@ class MailComponent(Component): self.__interval = int(config.get_content("config/check_interval")) self.__config = config -# self.__registered = {} try: self.__storage = globals()[config.get_content("config/storage") + "Storage"]() except: @@ -345,16 +344,17 @@ class MailComponent(Component): finally: ## TODO : for jid in self.__storage.keys(()) ## for name in self.__storage.keys((jid,)) -# for jid in self.__storage.keys(()): -# p = Presence(from_jid = str(self.jid), to_jid = jid, \ -# stanza_type = "unavailable") -# self.stream.send(p) -# for name in self.__registered[jid].keys(): -# if self.__storage[(jid, name)].status != "offline": -# p = Presence(from_jid = name + "@" + str(self.jid), \ -# to_jid = jid, \ -# stanza_type = "unavailable") -# self.stream.send(p) + if self.stream: + for jid in self.__storage.keys(()): + p = Presence(from_jid = str(self.jid), to_jid = jid, \ + stanza_type = "unavailable") + self.stream.send(p) + for jid, name in self.__storage.keys(): + if self.__storage[(jid, name)].status != "offline": + p = Presence(from_jid = name + "@" + str(self.jid), \ + to_jid = jid, \ + stanza_type = "unavailable") + self.stream.send(p) threads = threading.enumerate() for th in threads: try: @@ -367,7 +367,7 @@ class MailComponent(Component): except: pass self.disconnect() - del self.__storage + del self.__storage self.__logger.debug("Exitting normally") """ Stop method handler """ @@ -392,10 +392,14 @@ class MailComponent(Component): def authenticated(self): self.__logger.debug("AUTHENTICATED") Component.authenticated(self) -# for jid in self.__registered.keys(): -# p = Presence(from_jid = str(self.jid), \ -# to_jid = jid, stanza_type = "probe") -# self.stream.send(p) + for jid, name in self.__storage.keys(): + p = Presence(from_jid = name + "@" + str(self.jid), \ + to_jid = jid, stanza_type = "probe") + self.stream.send(p) + for jid in self.__storage.keys(()): + p = Presence(from_jid = str(self.jid), \ + to_jid = jid, stanza_type = "probe") + self.stream.send(p) self.stream.set_iq_get_handler("query", "jabber:iq:version", \ self.get_version) @@ -445,9 +449,9 @@ class MailComponent(Component): self.__logger.debug("DISCO_GET_ITEMS") base_from_jid = str(iq.get_from().bare()) di = DiscoItems() - if not node and self.__registered.has_key(base_from_jid): - for name in self.__registered[base_from_jid].keys(): - account = self.__registered[base_from_jid][name] + if not node: + for jid, name in self.__storage.keys(): + account = self.__storage[(jid, name)] str_name = account.get_type() + " connection " + name if account.get_type()[0:4] == "imap": str_name += " (" + account.mailbox + ")" @@ -488,18 +492,16 @@ class MailComponent(Component): remove = iq.xpath_eval("r:query/r:remove", \ {"r" : "jabber:iq:register"}) if remove: - if self.__registered.has_key(base_from_jid): - for name in self.__registered[base_from_jid].keys(): - p = Presence(from_jid = name + "@" + str(self.jid), \ - to_jid = from_jid, \ - stanza_type = "unsubscribe") - self.stream.send(p) - p = Presence(from_jid = name + "@" + str(self.jid), \ - to_jid = from_jid, \ - stanza_type = "unsubscribed") - self.stream.send(p) - del self.__registered[base_from_jid] -# self.__storage. + for jid, name in self.__storage.keys(): + p = Presence(from_jid = name + "@" + str(self.jid), \ + to_jid = from_jid, \ + stanza_type = "unsubscribe") + self.stream.send(p) + p = Presence(from_jid = name + "@" + str(self.jid), \ + to_jid = from_jid, \ + stanza_type = "unsubscribed") + self.stream.send(p) + del self.__storage[(jid, name)] p = Presence(from_jid = self.jid, to_jid = from_jid, \ stanza_type = "unsubscribe") self.stream.send(p) @@ -585,9 +587,8 @@ class MailComponent(Component): iq = iq.make_result_response() self.stream.send(iq) - if not self.__registered.has_key(base_from_jid): - self.__registered[base_from_jid] = {} - p = Presence(from_jid = self.jid, to_jid = from_jid.bare(), \ + if not self.__storage.has_key((base_from_jid,)): + p = Presence(from_jid = self.jid, to_jid = base_from_jid, \ stanza_type="subscribe") self.stream.send(p) @@ -596,7 +597,7 @@ class MailComponent(Component): socket = host + ":" + str(port) else: socket = host - if self.__registered[base_from_jid].has_key(name): + if self.__storage.has_key((base_from_jid, name)): m = Message(from_jid = self.jid, to_jid = from_jid, \ stanza_type = "message", \ body = u"Updated %s connection '%s': Registered with "\ @@ -611,31 +612,28 @@ class MailComponent(Component): % (type, name, login, password, socket)) self.stream.send(m) p = Presence(from_jid = name + "@" + str(self.jid), \ - to_jid = from_jid.bare(), \ + to_jid = base_from_jid, \ stanza_type="subscribe") self.stream.send(p) - self.__registered[base_from_jid][name] = \ - mailconnection_factory.get_new_mail_connection(type) - self.__registered[base_from_jid][name].login = login - self.__registered[base_from_jid][name].password = password - self.__registered[base_from_jid][name].host = host - self.__registered[base_from_jid][name].ffc_action = ffc_action - self.__registered[base_from_jid][name].online_action = online_action - self.__registered[base_from_jid][name].away_action = away_action - self.__registered[base_from_jid][name].ea_action = ea_action - self.__registered[base_from_jid][name].offline_action = offline_action + self.__storage[(base_from_jid, name)] = account = \ + mailconnection_factory.get_new_mail_connection(type) + account.login = login + account.password = password + account.host = host + account.ffc_action = ffc_action + account.online_action = online_action + account.away_action = away_action + account.ea_action = ea_action + account.offline_action = offline_action + account.interval = interval if port: - self.__registered[base_from_jid][name].port = port - - if interval: - self.__registered[base_from_jid][name].interval = interval + account.port = port if type[0:4] == "imap": - self.__registered[base_from_jid][name].mailbox = mailbox + account.mailbox = mailbox - self.__storage.add([base_from_jid, name], self.__registered[base_from_jid][name]) return 1 """ Handle presence availability """ @@ -646,38 +644,28 @@ class MailComponent(Component): name = stanza.get_to().node show = stanza.get_show() self.__logger.debug("SHOW : " + str(show)) - if self.__registered.has_key(base_from_jid): - if not name: - p = Presence(from_jid = self.jid, \ - to_jid = from_jid, \ - status = \ - str(len(self.__registered[base_from_jid])) \ - + " accounts registered.", \ - show = show, \ - stanza_type = "available") - self.stream.send(p) - for name in self.__registered[base_from_jid].keys(): - account = self.__registered[base_from_jid][name] - # Make available to receive mail only when online - account.status = "offline" # TODO get real status available = (not show) - p = Presence(from_jid = name + "@" + \ - str(self.jid), \ - to_jid = from_jid, \ - status = account.get_status(), \ - show = show, \ - stanza_type = "available") - self.stream.send(p) - elif self.__registered[base_from_jid].has_key(name): - account = self.__registered[base_from_jid][name] - # Make available to receive mail only when online - account.status = "offline" # TODO get real status = (not show) - p = Presence(from_jid = name + "@" + \ - str(self.jid), \ - to_jid = from_jid, \ - status = account.get_status(), \ - show = show, \ - stanza_type = "available") - self.stream.send(p) + if name: + self.__logger.debug("TO : " + name + " " + base_from_jid) + if not name and self.__storage.has_key((base_from_jid,)): + p = Presence(from_jid = self.jid, \ + to_jid = from_jid, \ + status = \ + str(len(self.__storage.keys((base_from_jid,)))) \ + + " accounts registered.", \ + show = show, \ + stanza_type = "available") + self.stream.send(p) + elif self.__storage.has_key((base_from_jid, name)): + account = self.__storage[(base_from_jid, name)] + # Make available to receive mail only when online + account.status = "online" # TODO get real status = (not show) + p = Presence(from_jid = name + "@" + \ + str(self.jid), \ + to_jid = from_jid, \ + status = account.get_status_msg(), \ + show = show, \ + stanza_type = "available") + self.stream.send(p) return 1 """ handle presence unavailability """ @@ -685,10 +673,9 @@ class MailComponent(Component): self.__logger.debug("PRESENCE_UNAVAILABLE") from_jid = stanza.get_from() base_from_jid = str(from_jid.bare()) - if stanza.get_to() == str(self.jid) \ - and self.__registered.has_key(base_from_jid): - for name in self.__registered[base_from_jid].keys(): - self.__registered[base_from_jid][name].status = "offline" # TODO get real status + if stanza.get_to() == str(self.jid): + for jid, name in self.__storage.keys(): + self.__storage[(base_from_jid, name)].status = "offline" # TODO get real status p = Presence(from_jid = name + "@" + str(self.jid), \ to_jid = from_jid, \ stanza_type = "unavailable") @@ -712,12 +699,11 @@ class MailComponent(Component): name = stanza.get_to().node from_jid = stanza.get_from() base_from_jid = str(from_jid.bare()) - if self.__registered.has_key(base_from_jid) \ - and self.__registered[base_from_jid].has_key(name): - account = self.__registered[base_from_jid][name] + if name is not None and self.__storage.has_key((base_from_jid, name)): + account = self.__storage[(base_from_jid, name)] account.status = "online" # TODO retrieve real status p = Presence(from_jid = stanza.get_to(), to_jid = from_jid, \ - status = account.get_status(), \ + status = account.get_status_msg(), \ stanza_type = "available") self.stream.send(p) return 1 @@ -728,9 +714,8 @@ class MailComponent(Component): name = stanza.get_to().node from_jid = stanza.get_from() base_from_jid = str(from_jid.bare()) - if self.__registered.has_key(base_from_jid) \ - and self.__registered[base_from_jid].has_key(name): - del self.__registered[base_from_jid][name] + if name is not None and self.__storage.has_key((base_from_jid, name)): + del self.__storage[(base_from_jid, name)] p = Presence(from_jid = stanza.get_to(), to_jid = from_jid, \ stanza_type = "unsubscribe") self.stream.send(p) @@ -752,20 +737,20 @@ class MailComponent(Component): self.__logger.debug("MESSAGE: " + message.get_body()) name = message.get_to().node base_from_jid = str(message.get_from().bare()) - if name and self.__registered.has_key(base_from_jid): - body = message.get_body() - cmd = body.split(' ') - if cmd[0] == "check": - self.check_mail(base_from_jid, name) - elif cmd[0] == "dump": - body = "" - for jid in self.__registered.keys(): - for name in self.__registered[jid].keys(): - body += name + " for user " + jid - msg = Message(from_jid = self.jid, to_jid = base_from_jid, \ - stanza_type = "message", \ - body = body) - self.stream.send(msg) +# if name and self.__registered.has_key(base_from_jid): +# body = message.get_body() +# cmd = body.split(' ') +# if cmd[0] == "check": +# self.check_mail(base_from_jid, name) +# elif cmd[0] == "dump": +# body = "" +# for jid in self.__registered.keys(): +# for name in self.__registered[jid].keys(): +# body += name + " for user " + jid +# msg = Message(from_jid = self.jid, to_jid = base_from_jid, \ +# stanza_type = "message", \ +# body = body) +# self.stream.send(msg) return 1 # """ Store registered sessions """ @@ -863,6 +848,7 @@ class MailComponent(Component): """ check mail handler """ def check_all_mail(self): self.__logger.debug("CHECK_ALL_MAIL") - for jid in self.__registered.keys(): - for name in self.__registered[jid].keys(): - self.check_mail(jid, name) + ## TODO +# for jid in self.__registered.keys(): +# for name in self.__registered[jid].keys(): +# self.check_mail(jid, name) diff --git a/jabber/mailconnection.py b/jabber/mailconnection.py index 7f82925..e1b16b5 100644 --- a/jabber/mailconnection.py +++ b/jabber/mailconnection.py @@ -156,6 +156,7 @@ class MailConnection(object): self.away_action = RETRIEVE self.ea_action = RETRIEVE self.offline_action = DO_NOTHING + self.interval = 5 def __eq__(self, other): return self.get_type() == other.get_type() \ @@ -168,8 +169,9 @@ class MailConnection(object): and self.online_action == other.online_action \ and self.away_action == other.away_action \ and self.ea_action == other.ea_action \ - and self.offline_action == other.offline_action - + and self.offline_action == other.offline_action \ + and self.interval == other.interval + def __str__(self): return self.get_type() + "#" + self.login + "#" + self.password + "#" \ + self.host + "#" + str(self.port) + "#" + str(self.ffc_action) + "#" \ @@ -219,7 +221,7 @@ class MailConnection(object): def get_type(self): return "UNKNOWN" - def get_status(self): + def get_status_msg(self): return self.get_type() + "://" + self.login + "@" + self.host + ":" + \ str(self.port) @@ -246,7 +248,7 @@ class MailConnection(object): "offline": self.offline_action} if mapping.has_key(self.status): return mapping[self.status] - return "nothing" + return NOTHING action = property(get_action) diff --git a/jabber/storage.py b/jabber/storage.py index 805bfcc..985d8fd 100644 --- a/jabber/storage.py +++ b/jabber/storage.py @@ -66,38 +66,29 @@ class DBMStorage(Storage): def __init__(self, nb_pk_fields = 1, spool_dir = "."): # print "DBM INIT" Storage.__init__(self, nb_pk_fields, spool_dir) - self.__str_registered = anydbm.open(self.file, \ - 'c') + self.__registered = self.load() def __del__(self): -# print "DBM STOP" - self.__str_registered.close() - + # print "DBM STOP" + self.sync() + def load(self): # print "DBM LOAD" + str_registered = anydbm.open(self.file, \ + 'c') result = {} try: - for pk in self.__str_registered.keys(): - pk_list = pk.split('#') - obj = result - key = None - while pk_list: - key = pk_list.pop(0) - if pk_list: - if not obj.has_key(key): - obj[key] = {} - obj = obj[key] - obj[key] = mailconnection_factory.str_to_mail_connection(self.__str_registered[pk]) + for pk in str_registered.keys(): + result[pk] = mailconnection_factory.str_to_mail_connection(str_registered[pk]) except Exception, e: print >>sys.stderr, "Cannot load registered.db : " print >>sys.stderr, e + str_registered.close() return result def sync(self): -# print "DBM SYNC" - self.__str_registered.close() - self.__str_registered = anydbm.open(self.file, \ - 'c') + # print "DBM SYNC" + self.store() def __store(self, nb_pk_fields, registered, pk): if nb_pk_fields > 0: @@ -112,52 +103,68 @@ class DBMStorage(Storage): self.__str_registered[pk] = str(registered) print "STORING : " + pk + " = " + str(registered) - def store(self, registered): + def store(self): # print "DBM STORE" try: - self.__store(self.nb_pk_fields, registered, "") - # Force file synchronisation - self.sync() + str_registered = anydbm.open(self.file, \ + 'c') + for pk in self.__registered.keys(): + str_registered[pk] = str(self.__registered[pk]) except Exception, e: print >>sys.stderr, "Cannot save to registered.db : " print >>sys.stderr, e - + str_registered.close() + def __setitem__(self, pk_tuple, obj): # print "Adding " + "#".join(pk_tuple) + " = " + str(obj) - self.__str_registered["#".join(pk_tuple)] = str(obj) + self.__registered[str("#".join(pk_tuple))] = obj self.sync() def __getitem__(self, pk_tuple): # print "Getting " + "#".join(pk_tuple) if len(pk_tuple) == self.nb_pk_fields: - return mailconnection_factory.str_to_mail_connection(self.__str_registered["#".join(pk_tuple)]) + return self.__registered[str("#".join(pk_tuple))] else: - partial_key = "#".join(pk_tuple) + partial_key = str("#".join(pk_tuple)) regexp = re.compile(partial_key) - return [mailconnection_factory.str_to_mail_connection(self.__str_registered[key]) - for key in self.__str_registered.keys() + return [self.__registered[key] + for key in self.__registered.keys() if regexp.search(key)] def __delitem__(self, pk_tuple): # print "Deleting " + "#".join(pk_tuple) - del self.__str_registered["#".join(pk_tuple)] + del self.__registered[str("#".join(pk_tuple))] self.sync() def has_key(self, pk_tuple): - return self.__str_registered.has_key("#".join(pk_tuple)) + if len(pk_tuple) == self.nb_pk_fields: + return self.__registered.has_key(str("#".join(pk_tuple))) + else: + partial_key = str("#".join(pk_tuple)) + regexp = re.compile("^" + partial_key) + for key in self.__registered.keys(): + if regexp.search(key): + return True + return False def keys(self, pk_tuple = None): if pk_tuple is None: - return [tuple(key.split("#")) for key in self.__str_registered.keys()] + return [tuple(key.split("#")) for key in self.__registered.keys()] else: level = len(pk_tuple) - partial_key = "#".join(pk_tuple) + partial_key = str("#".join(pk_tuple)) regexp = re.compile("^" + partial_key) result = {} - for key in self.__str_registered.keys(): + for key in self.__registered.keys(): if regexp.search(key): result[key.split("#")[level]] = None return result.keys() + + def dump(self): + print "dumping" + for pk in self.__registered.keys(): + print pk + " = " + str(self.__registered[pk]) + class SQLiteStorage(Storage): def __init__(self, nb_pk_fields = 1, spool_dir = "."): diff --git a/run_test.py b/run_test.py index a281fa2..b3b7027 100644 --- a/run_test.py +++ b/run_test.py @@ -32,8 +32,12 @@ from tests.test_component import * from tests.test_storage import * from test import test_support import jabber +import logging if __name__ == '__main__': + logger = logging.getLogger() + logger.addHandler(logging.StreamHandler()) + logger.setLevel(logging.INFO) mail_connection_suite = unittest.makeSuite(MailConnection_TestCase, \ "test") pop3_connection_suite = unittest.makeSuite(POP3Connection_TestCase, \ @@ -59,7 +63,7 @@ if __name__ == '__main__': component2_suite, \ storage_suite, \ dbmstorage_suite)) - test_support.run_suite(component2_suite) + test_support.run_suite(storage_suite) # coverage.stop() # coverage.analysis(jabber.mailconnection_factory) diff --git a/tests/dummy_server.py b/tests/dummy_server.py index 83e7c31..2519662 100644 --- a/tests/dummy_server.py +++ b/tests/dummy_server.py @@ -55,9 +55,6 @@ class DummyServer: self.queries = None self.real_queries = [] - def __del__(self): - self.socket.close() - def serve(self): conn, addr = self.socket.accept() rfile = conn.makefile('rb', -1) @@ -80,6 +77,8 @@ class DummyServer: self.real_queries.append(data) # print >>sys.stderr, 'Receive : ', data conn.close() + self.socket.close() + self.socket = None def verify_queries(self): result = True @@ -114,8 +113,10 @@ class XMLDummyServer(DummyServer): # TODO : this approximation is not clean # received size is based on the expected size in self.queries data = conn.recv(1024 + len(self.queries[idx])) + print "receive : " + data if data: -# print "-----------RECEIVE " + data + ## TODO : without this log, test_set_register in test_component wait forever + #print "-----------RECEIVE1 " + data r = self._reader.feed(data) except: type, value, stack = sys.exc_info() @@ -132,9 +133,16 @@ class XMLDummyServer(DummyServer): else: response = self.responses[idx] if response is not None: -# print >>sys.stderr, '---------SENDING : ', response + print >>sys.stderr, '---------SENDING : ', response conn.send(response) + data = conn.recv(1024) + if data: + print "-----------RECEIVE2 " + data + r = self._reader.feed(data) + self.real_queries.append(data) conn.close() + self.socket.close() + self.socket = None except: type, value, stack = sys.exc_info() print "".join (traceback.format_exception @@ -143,26 +151,21 @@ class XMLDummyServer(DummyServer): def verify_queries(self): result = True - queries_len = len(self.queries) - if queries_len == len(self.real_queries): - full_real_queries = "" - full_recv_queries = "" - for idx in range(queries_len): - full_real_queries += self.real_queries[idx].rstrip(os.linesep) - full_recv_queries += self.queries[idx].rstrip(os.linesep) - # Do not receive it but add it so that xml parsing can succeed - full_real_queries += "" - real_query = xml.dom.minidom.parseString(full_real_queries) - recv_query = xml.dom.minidom.parseString(full_recv_queries) - try: - utils.xmldiff(real_query, recv_query) - except Exception, msg: - result = False - print >>sys.stderr, msg - else: + full_real_queries = "" + full_recv_queries = "" + for idx in range(len(self.real_queries)): + full_real_queries += self.real_queries[idx].rstrip(os.linesep) + full_recv_queries += self.queries[idx].rstrip(os.linesep) + # Do not receive it but add it so that xml parsing can succeed + #full_real_queries += "" + print full_real_queries + real_query = xml.dom.minidom.parseString(full_real_queries) + recv_query = xml.dom.minidom.parseString(full_recv_queries) + try: + utils.xmldiff(real_query, recv_query) + except Exception, msg: result = False - print >>sys.stderr, "Expected " + str(queries_len) + \ - " queries, got " + str(len(self.real_queries)) + print >>sys.stderr, msg return result def test(): diff --git a/tests/test_component.py b/tests/test_component.py index 3b46bae..0c57988 100644 --- a/tests/test_component.py +++ b/tests/test_component.py @@ -66,12 +66,14 @@ class MailComponent_TestCase_Basic(unittest.TestCase): def tearDown(self): self.server = None self.mail_component = None + os.remove("./registered.db") def test_run(self): self.server.responses = ["", \ ""] self.server.queries = ["", \ - "[0-9abcdef]*"] + "[0-9abcdef]*", + ""] self.mail_component.run(1) self.failUnless(self.server.verify_queries()) # TODO : more assertion @@ -79,9 +81,6 @@ class MailComponent_TestCase_Basic(unittest.TestCase): class MailComponent_TestCase_NoReg(unittest.TestCase): def setUp(self): self.handler = TestStreamHandler() -# logger = logging.getLogger() -# logger.addHandler(logging.StreamHandler()) -# logger.setLevel(logging.DEBUG) self.mail_component = MailComponent(Config("tests/jmc-test.xml")) self.server = dummy_server.XMLDummyServer("localhost", 55555, None, self.handler) thread.start_new_thread(self.server.serve, ()) @@ -89,25 +88,28 @@ class MailComponent_TestCase_NoReg(unittest.TestCase): def tearDown(self): self.server = None self.mail_component = None + ## TODO : be storage independant + os.remove("./registered.db") def test_disco_get_items(self): - self.server.responses = ["", \ - "", \ + self.server.responses = ["", + "", ""] self.server.queries = ["" + \ "", \ - "[0-9abcdef]*", \ - ""] + "[0-9abcdef]*", + "", + ""] self.mail_component.run(1) self.failUnless(self.server.verify_queries()) def test_get_register(self): - self.server.responses = ["", \ - "", \ + self.server.responses = ["", + "", ""] self.server.queries = ["" + \ "", \ - "[0-9abcdef]*", \ + "[0-9abcdef]*", "" + \ "" + \ "" + \ @@ -200,84 +202,90 @@ class MailComponent_TestCase_NoReg(unittest.TestCase): "" + \ "" + \ "" + \ - "" + \ + "", ""] self.mail_component.run(1) self.failUnless(self.server.verify_queries()) def test_disco_get_info(self): - self.server.responses = ["", \ - "", \ + self.server.responses = ["", + "", ""] self.server.queries = ["" + \ - "", \ - "[0-9abcdef]*", \ + "", + "[0-9abcdef]*", "" + \ "" + \ "" + \ "" + \ "" + \ - "" + \ + "", ""] self.mail_component.run(1) self.failUnless(self.server.verify_queries()) -# def test_set_register(self): -# self.server.responses = ["", \ -# "" + \ -# "" + \ -# "" + \ -# "" + \ -# "" + \ -# "test" + \ -# "" + \ -# "" + \ -# "logintest" + \ -# "" + \ -# "" + \ -# "passtest" + \ -# "" + \ -# "" + \ -# "hosttest" + \ -# "" + \ -# "" + \ -# "993" + \ -# "" + \ -# "" + \ -# "imaps" + \ -# "" + \ -# "" + \ -# "INBOX" + \ -# "" + \ -# "" + \ -# "2" + \ -# "" + \ -# "" + \ -# "2" + \ -# "" + \ -# "" + \ -# "1" + \ -# "" + \ -# "" + \ -# "1" + \ -# "" + \ -# "" + \ -# "0" + \ -# "" + \ -# "" + \ -# "5" + \ -# "" + \ -# "" + \ -# "" + \ -# ""] -# self.server.queries = ["" + \ -# "", \ -# "[0-9abcdef]*", \ -# "", -# ""] -# self.mail_component.run(1) -# self.failUnless(self.server.verify_queries()) + def test_set_register(self): + self.server.responses = ["", \ + "" + \ + "" + \ + "" + \ + "" + \ + "" + \ + "test" + \ + "" + \ + "" + \ + "logintest" + \ + "" + \ + "" + \ + "passtest" + \ + "" + \ + "" + \ + "hosttest" + \ + "" + \ + "" + \ + "993" + \ + "" + \ + "" + \ + "imaps" + \ + "" + \ + "" + \ + "INBOX" + \ + "" + \ + "" + \ + "2" + \ + "" + \ + "" + \ + "2" + \ + "" + \ + "" + \ + "1" + \ + "" + \ + "" + \ + "1" + \ + "" + \ + "" + \ + "0" + \ + "" + \ + "" + \ + "5" + \ + "" + \ + "" + \ + "", + lambda x: None, + lambda x: None, + lambda x: None, + ""] + self.server.queries = ["" + \ + "", \ + "[0-9abcdef]*", \ + "", + "", + "New imaps connection \\'test\\': Registered with username \\'logintest\\' and password \\'passtest\\' on \\'hosttest:993\\'", + "", + ""] + self.mail_component.run(1) + self.failUnless(self.server.verify_queries()) class MailComponent_TestCase_Reg(unittest.TestCase): def setUp(self): diff --git a/tests/test_storage.py b/tests/test_storage.py index 1dd3fb7..62a4a20 100644 --- a/tests/test_storage.py +++ b/tests/test_storage.py @@ -97,8 +97,11 @@ class DBMStorage_TestCase(unittest.TestCase): def test_haskey(self): self._storage[("test@localhost", "account2")] = self._account2 - self.assertTrue(self._storage.has_key(("test@localhost", "account2"))) + self.assertTrue(self._storage.has_key((u"test@localhost", u"account2"))) + def test_partial_haskey(self): + self._storage[("test@localhost", "account2")] = self._account2 + self.assertTrue(self._storage.has_key((u"test@localhost",))) def test_get_filtered(self): self._storage[("test@localhost", "account1")] = self._account1 @@ -106,8 +109,8 @@ class DBMStorage_TestCase(unittest.TestCase): result = self._storage[("test@localhost",)] self.assertEquals(type(result), list) self.assertEquals(len(result), 2) - self.assertEquals(result[0], self._account1) - self.assertEquals(result[1], self._account2) + self.assertEquals(result[1], self._account1) + self.assertEquals(result[0], self._account2) def test_get_filtered2(self): self._storage[("test@localhost", "account1")] = self._account1 @@ -123,14 +126,14 @@ class DBMStorage_TestCase(unittest.TestCase): result = self._storage.keys() self.assertEquals(type(result), list) self.assertEquals(len(result), 2) - self.assertEquals(type(result[0]), tuple) - self.assertEquals(len(result[0]), 2) - self.assertEquals(result[0][0], "test@localhost") - self.assertEquals(result[0][1], "account1") self.assertEquals(type(result[1]), tuple) self.assertEquals(len(result[1]), 2) self.assertEquals(result[1][0], "test@localhost") - self.assertEquals(result[1][1], "account2") + self.assertEquals(result[1][1], "account1") + self.assertEquals(type(result[0]), tuple) + self.assertEquals(len(result[0]), 2) + self.assertEquals(result[0][0], "test@localhost") + self.assertEquals(result[0][1], "account2") def test_keys_filtered(self): self._storage[("test@localhost", "account1")] = self._account1