separate out FFI eventracking to only be used in running tests

python/src/deltachat/account.py

@@ -42,15 +42,16 @@ class Account(object):
         self._evlogger = EventLogger(self, logid, debug)
         self._threads = IOThreads(self._dc_context, self._evlogger._log_event)
 
-        # register event call back and initialize per-account plugin system
+        # initialize per-account plugin system
+        self.plugin_manager = AccountHookSpecs._make_plugin_manager()
+        self.plugin_manager.register(self._evlogger)
+
+        # send all FFI events for this account to a plugin hook
         def _ll_event(ctx, evt_name, data1, data2):
             assert ctx == self._dc_context
             self.plugin_manager.hook.process_low_level_event(
                 account=self, event_name=evt_name, data1=data1, data2=data2
             )
-
-        self.plugin_manager = AccountHookSpecs._make_plugin_manager()
-        self.plugin_manager.register(self._evlogger)
         deltachat.set_context_callback(self._dc_context, _ll_event)
 
         # open database
@@ -481,11 +482,6 @@ class Account(object):
     # meta API for start/stop and event based processing
     #
 
-    def wait_next_incoming_message(self):
-        """ wait for and return next incoming message. """
-        ev = self._evlogger.get_matching("DC_EVENT_INCOMING_MSG")
-        return self.get_message_by_id(ev[2])
-
     def start_threads(self, mvbox=False, sentbox=False):
         """ start IMAP/SMTP threads (and configure account if it hasn't happened).
 

python/src/deltachat/eventlogger.py

@@ -1,7 +1,5 @@
 import threading
-import re
 import time
-from queue import Queue, Empty
 from .hookspec import account_hookimpl
 
 
@@ -10,58 +8,15 @@ class EventLogger:
 
     def __init__(self, account, logid=None, debug=True):
         self.account = account
-        self._event_queue = Queue()
         self._debug = debug
         if logid is None:
             logid = str(self.account._dc_context).strip(">").split()[-1]
         self.logid = logid
-        self._timeout = None
         self.init_time = time.time()
 
     @account_hookimpl
     def process_low_level_event(self, event_name, data1, data2):
         self._log_event(event_name, data1, data2)
-        self._event_queue.put((event_name, data1, data2))
-
-    def set_timeout(self, timeout):
-        self._timeout = timeout
-
-    def consume_events(self, check_error=True):
-        while not self._event_queue.empty():
-            self.get(check_error=check_error)
-
-    def get(self, timeout=None, check_error=True):
-        timeout = timeout or self._timeout
-        ev = self._event_queue.get(timeout=timeout)
-        if check_error and ev[0] == "DC_EVENT_ERROR":
-            raise ValueError("{}({!r},{!r})".format(*ev))
-        return ev
-
-    def ensure_event_not_queued(self, event_name_regex):
-        __tracebackhide__ = True
-        rex = re.compile("(?:{}).*".format(event_name_regex))
-        while 1:
-            try:
-                ev = self._event_queue.get(False)
-            except Empty:
-                break
-            else:
-                assert not rex.match(ev[0]), "event found {}".format(ev)
-
-    def get_matching(self, event_name_regex, check_error=True, timeout=None):
-        self._log("-- waiting for event with regex: {} --".format(event_name_regex))
-        rex = re.compile("(?:{}).*".format(event_name_regex))
-        while 1:
-            ev = self.get(timeout=timeout, check_error=check_error)
-            if rex.match(ev[0]):
-                return ev
-
-    def get_info_matching(self, regex):
-        rex = re.compile("(?:{}).*".format(regex))
-        while 1:
-            ev = self.get_matching("DC_EVENT_INFO")
-            if rex.match(ev[2]):
-                return ev
 
     def _log_event(self, evt_name, data1, data2):
         # don't show events that are anyway empty impls now