Fix plugin reloading before test start (#258)

This commit ...

1. refactors reloader's dummy plugin install/removal by using set_timeout()
   to check for dummy being loaded in order to not block the calling thread.
2. uses an `on_done` callback to continue operation after dummy has been
   removed.
3. always loads a dummy plugin as it is required to teach ST about new
   command and event instances. It does not work without that step.

Before this commit the whole UI thread was blocked, causing dummy plugin not
being reloaded until timeout was hit. Running tests on worker thread had other
negative impacts.

Reloading now behaves like "DefferableTextTestRunner" using set_timeout to
schedule coroutines.

Author: deathaxe

README.md

@@ -140,7 +140,6 @@ UnitTesting could be configured by providing the following settings in `unittest
 | verbosity                   | verbosity level                                                                   | 2             |
 | capture_console             | capture stdout and stderr in the test output                                      | false         |
 | reload_package_on_testing   | reloading package will increase coverage rate                                     | true          |
-| show_reload_progress        | print a detailed list of reloaded modules to console                              | false         |
 | coverage                    | track test case coverage                                                          | false         |
 | coverage_on_worker_thread   | (experimental)                                                                    | false         |
 | generate_html_report        | generate HTML report for coverage                                                 | false         |

sublime-package.json

@@ -35,10 +35,6 @@
               "type": ["string", "null"],
               "markdownDescription": "Name of the test output instead of showing in the panel.",
             },
-            "show_reload_progress": {
-              "type": "boolean",
-              "default": true,
-            },
             "reload_package_on_testing": {
               "type": "boolean",
               "default": true,
@@ -49,11 +45,6 @@
               "default": false,
               "markdownDescription": "Create coverage report.",
             },
-            "start_coverage_after_reload": {
-              "type": "boolean",
-              "default": false,
-              "markdownDescription": "Irrelevent if  `reload_package_on_testing` is false.",
-            },
             "coverage_on_worker_thread": {
               "type": "boolean",
               "default": false,

unittesting/base.py

@@ -24,7 +24,6 @@
     "capture_console": False,
     # reloader
     "reload_package_on_testing": True,
-    "show_reload_progress": False,
     # coverage
     "coverage": False,
     "coverage_on_worker_thread": False,   # experimental

unittesting/unit.py

@@ -94,17 +94,20 @@ def run(self, package=None, **kwargs):
 
         stream = self.load_stream(package, settings)
 
-        if settings["async"]:
-            threading.Thread(
-                target=self.run_coverage, args=(package, stream, settings)
-            ).start()
-        else:
-            self.run_coverage(package, stream, settings)
+        def run_tests():
+            if settings["async"]:
+                threading.Thread(
+                    target=self.run_coverage, args=(package, stream, settings)
+                ).start()
+            else:
+                self.run_coverage(package, stream, settings)
 
-    def run_coverage(self, package, stream, settings):
         if settings["reload_package_on_testing"]:
-            reload_package(package)
+            reload_package(package, on_done=run_tests)
+        else:
+            run_tests()
 
+    def run_coverage(self, package, stream, settings):
         if not coverage or not settings["coverage"]:
             if settings["coverage"]:
                 stream.write("Warning: coverage cannot be loaded.\n\n")
@@ -139,8 +142,6 @@ def run_coverage(self, package, stream, settings):
         cov.start()
 
         if settings["coverage_on_worker_thread"]:
-            import threading
-
             original_set_timeout_async = sublime.set_timeout_async
 
             def set_timeout_async(callback, *args, **kwargs):

unittesting/utils/reloader.py

@@ -5,16 +5,6 @@
 import sublime
 import sublime_plugin
 import sys
-import threading
-
-
-def dprint(*args, fill=None, fill_width=60, **kwargs):
-    if fill is not None:
-        sep = str(kwargs.get('sep', ' '))
-        caption = sep.join(args)
-        args = "{0:{fill}<{width}}".format(caption and caption + sep,
-                                           fill=fill, width=fill_width),
-    print("UnitTesting:", *args, **kwargs)
 
 
 def path_contains(a, b):
@@ -61,8 +51,10 @@ def package_plugins(pkg_name):
     ]
 
 
-def reload_package(pkg_name, dummy=True, verbose=True):
+def reload_package(pkg_name, on_done=None):
     if pkg_name not in sys.modules:
+        if on_done:
+            sublime.set_timeout(on_done)
         return
 
     all_modules = {
@@ -89,21 +81,8 @@ def reload_package(pkg_name, dummy=True, verbose=True):
     for plugin in plugins:
         sublime_plugin.reload_plugin(plugin)
 
-    # Install and uninstall a dummy package so ST updates
-    # command and event listener bindings
-    if dummy:
-        load_dummy(verbose)
-
-
-def load_dummy(verbose):
-    """
-    Hack to trigger automatic "reloading plugins".
-
-    This is needed to ensure TextCommand's and WindowCommand's are ready.
-    """
-    if verbose:
-        dprint("installing dummy package")
-
+    # Hack to trigger automatic "reloading plugins".
+    # This is needed to ensure TextCommand's and WindowCommand's are ready.
     if sys.version_info >= (3, 8):
         # in ST 4, User package is always loaded in python 3.8
         dummy_name = "User._dummy"
@@ -113,37 +92,15 @@ def load_dummy(verbose):
         dummy_name = "_dummy"
         dummy_py = os.path.join(sublime.packages_path(), "_dummy.py")
 
-    with open(dummy_py, "w"):
-        pass
-
-    def remove_dummy(trial=0):
-        if dummy_name in sys.modules:
-            if verbose:
-                dprint("removing dummy package")
-            try:
-                os.unlink(dummy_py)
-            except FileNotFoundError:
-                pass
-            after_remove_dummy()
-        elif trial < 300:
-            threading.Timer(0.1, lambda: remove_dummy(trial + 1)).start()
-        else:
-            try:
-                os.unlink(dummy_py)
-            except FileNotFoundError:
-                pass
-
-    condition = threading.Condition()
-
-    def after_remove_dummy(trial=0):
+    open(dummy_py, "a").close()
+
+    def check_loaded():
         if dummy_name not in sys.modules:
-            condition.acquire()
-            condition.notify()
-            condition.release()
-        elif trial < 300:
-            threading.Timer(0.1, lambda: after_remove_dummy(trial + 1)).start()
-
-    threading.Timer(0.1, remove_dummy).start()
-    condition.acquire()
-    condition.wait(30)  # 30 seconds should be enough for all regular usages
-    condition.release()
+            sublime.set_timeout(check_loaded, 100)
+            return
+
+        os.remove(dummy_py)
+        if on_done:
+            sublime.set_timeout(on_done, 200)
+
+    sublime.set_timeout(check_loaded, 100)