Reformat using black (#260)

Author: deathaxe

unittesting/base.py

@@ -14,7 +14,7 @@
     "tests_dir": "tests",
     "pattern": "test*.py",
     # runner
-    "async": False,                       # deprecated
+    "async": False,  # deprecated
     "deferred": True,
     "condition_timeout": 4000,
     "failfast": False,
@@ -26,7 +26,7 @@
     "reload_package_on_testing": True,
     # coverage
     "coverage": False,
-    "coverage_on_worker_thread": False,   # experimental
+    "coverage_on_worker_thread": False,  # experimental
     "generate_html_report": False,
     "generate_xml_report": False,
 }

unittesting/core/py33/case.py

@@ -12,10 +12,7 @@
 
 from .runner import defer
 
-__all__ = [
-    "DeferrableTestCase",
-    "expectedFailure"
-]
+__all__ = ["DeferrableTestCase", "expectedFailure"]
 
 
 def expectedFailure(func):
@@ -28,6 +25,7 @@ def wrapper(*args, **kwargs):
         except Exception:
             raise _ExpectedFailure(sys.exc_info())
         raise _UnexpectedSuccess
+
     return wrapper
 
 
@@ -72,19 +70,21 @@ def run(self, result=None):
         orig_result = result
         if result is None:
             result = self.defaultTestResult()
-            startTestRun = getattr(result, 'startTestRun', None)
+            startTestRun = getattr(result, "startTestRun", None)
             if startTestRun is not None:
                 startTestRun()
 
         result.startTest(self)
 
         testMethod = getattr(self, self._testMethodName)
-        if getattr(self.__class__, "__unittest_skip__", False) or \
-                getattr(testMethod, "__unittest_skip__", False):
+        if getattr(self.__class__, "__unittest_skip__", False) or getattr(
+            testMethod, "__unittest_skip__", False
+        ):
             # If the class or method was skipped.
             try:
-                skip_why = getattr(self.__class__, '__unittest_skip_why__', '') or \
-                    getattr(testMethod, '__unittest_skip_why__', '')
+                skip_why = getattr(
+                    self.__class__, "__unittest_skip_why__", ""
+                ) or getattr(testMethod, "__unittest_skip_why__", "")
                 self._addSkip(result, skip_why)
             finally:
                 result.stopTest(self)
@@ -109,29 +109,31 @@ def run(self, result=None):
                 for exc_info in outcome.failures:
                     result.addFailure(self, exc_info)
                 if outcome.unexpectedSuccess is not None:
-                    addUnexpectedSuccess = getattr(result, 'addUnexpectedSuccess', None)
+                    addUnexpectedSuccess = getattr(result, "addUnexpectedSuccess", None)
                     if addUnexpectedSuccess is not None:
                         addUnexpectedSuccess(self)
                     else:
                         warnings.warn(
                             "TestResult has no addUnexpectedSuccess method, reporting as failures",
-                            RuntimeWarning)
+                            RuntimeWarning,
+                        )
                         result.addFailure(self, outcome.unexpectedSuccess)
 
                 if outcome.expectedFailure is not None:
-                    addExpectedFailure = getattr(result, 'addExpectedFailure', None)
+                    addExpectedFailure = getattr(result, "addExpectedFailure", None)
                     if addExpectedFailure is not None:
                         addExpectedFailure(self, outcome.expectedFailure)
                     else:
                         warnings.warn(
                             "TestResult has no addExpectedFailure method, reporting as passes",
-                            RuntimeWarning)
+                            RuntimeWarning,
+                        )
                         result.addSuccess(self)
             return result
         finally:
             result.stopTest(self)
             if orig_result is None:
-                stopTestRun = getattr(result, 'stopTestRun', None)
+                stopTestRun = getattr(result, "stopTestRun", None)
                 if stopTestRun is not None:
                     stopTestRun()
 

unittesting/core/py33/runner.py

@@ -8,7 +8,7 @@
 
 DEFAULT_CONDITION_POLL_TIME = 17
 DEFAULT_CONDITION_TIMEOUT = 4000
-AWAIT_WORKER = 'AWAIT_WORKER'
+AWAIT_WORKER = "AWAIT_WORKER"
 # Extract `set_timeout_async`, t.i. *avoid* late binding, in case a user
 # patches it
 run_on_worker = sublime.set_timeout_async
@@ -34,7 +34,8 @@ def __init__(
         condition_timeout=DEFAULT_CONDITION_TIMEOUT,
     ):
         super(DeferringTextTestRunner, self).__init__(
-            stream, descriptions, verbosity, failfast, buffer, resultclass, warnings)
+            stream, descriptions, verbosity, failfast, buffer, resultclass, warnings
+        )
         self.condition_timeout = condition_timeout
 
     def run(self, test):
@@ -56,13 +57,13 @@ def _start_testing():
                     # no more than once per module, because they can be fairly
                     # noisy.  The -Wd and -Wa flags can be used to bypass this
                     # only when self.warnings is None.
-                    if self.warnings in ['default', 'always']:
+                    if self.warnings in ["default", "always"]:
                         warnings.filterwarnings(
-                            'module',
+                            "module",
                             category=DeprecationWarning,
-                            message='Please use assert\\w+ instead.'
+                            message="Please use assert\\w+ instead.",
                         )
-                startTestRun = getattr(result, 'startTestRun', None)
+                startTestRun = getattr(result, "startTestRun", None)
                 if startTestRun is not None:
                     startTestRun()
                 try:
@@ -81,8 +82,11 @@ def _continue_testing(deferred, send_value=None, throw_value=None):
 
                 if callable(condition):
                     defer(0, _wait_condition, deferred, condition)
-                elif isinstance(condition, dict) and "condition" in condition and \
-                        callable(condition["condition"]):
+                elif (
+                    isinstance(condition, dict)
+                    and "condition" in condition
+                    and callable(condition["condition"])
+                ):
                     period = condition.get("period", DEFAULT_CONDITION_POLL_TIME)
                     defer(period, _wait_condition, deferred, **condition)
                 elif isinstance(condition, int):
@@ -103,7 +107,7 @@ def _wait_condition(
             condition,
             period=DEFAULT_CONDITION_POLL_TIME,
             timeout=self.condition_timeout,
-            start_time=None
+            start_time=None,
         ):
             if start_time is None:
                 start_time = time.time()
@@ -118,41 +122,56 @@ def _wait_condition(
                 _continue_testing(deferred, send_value=send_value)
             elif (time.time() - start_time) * 1000 >= timeout:
                 error = TimeoutError(
-                    'Condition not fulfilled within {:.2f} seconds'
-                    .format(timeout / 1000)
+                    "Condition not fulfilled within {:.2f} seconds".format(
+                        timeout / 1000
+                    )
                 )
                 _continue_testing(deferred, throw_value=error)
             else:
-                defer(period, _wait_condition, deferred, condition, period, timeout, start_time)
+                defer(
+                    period,
+                    _wait_condition,
+                    deferred,
+                    condition,
+                    period,
+                    timeout,
+                    start_time,
+                )
 
         def _handle_error(e):
-            stopTestRun = getattr(result, 'stopTestRun', None)
+            stopTestRun = getattr(result, "stopTestRun", None)
             if stopTestRun is not None:
                 stopTestRun()
             self.finished = True
             raise e
 
         def _stop_testing():
             with warnings.catch_warnings():
-                stopTestRun = getattr(result, 'stopTestRun', None)
+                stopTestRun = getattr(result, "stopTestRun", None)
                 if stopTestRun is not None:
                     stopTestRun()
 
             stopTime = time.time()
             timeTaken = stopTime - startTime
             result.printErrors()
-            if hasattr(result, 'separator2'):
+            if hasattr(result, "separator2"):
                 self.stream.writeln(result.separator2)
             run = result.testsRun
-            self.stream.writeln("Ran %d test%s in %.3fs" %
-                                (run, run != 1 and "s" or "", timeTaken))
+            self.stream.writeln(
+                "Ran %d test%s in %.3fs" % (run, run != 1 and "s" or "", timeTaken)
+            )
             self.stream.writeln()
 
             expectedFails = unexpectedSuccesses = skipped = 0
             try:
-                results = map(len, (result.expectedFailures,
-                                    result.unexpectedSuccesses,
-                                    result.skipped))
+                results = map(
+                    len,
+                    (
+                        result.expectedFailures,
+                        result.unexpectedSuccesses,
+                        result.skipped,
+                    ),
+                )
             except AttributeError:
                 pass
             else:

unittesting/core/py33/suite.py

@@ -11,7 +11,7 @@ class DeferrableTestSuite(TestSuite):
 
     def run(self, result, debug=False):
         topLevel = False
-        if getattr(result, '_testRunEntered', False) is False:
+        if getattr(result, "_testRunEntered", False) is False:
             result._testRunEntered = topLevel = True
 
         for test in self:
@@ -31,8 +31,9 @@ def run(self, result, debug=False):
                 yield
                 result._previousTestClass = test.__class__
 
-                if getattr(test.__class__, '_classSetupFailed', False) or \
-                        getattr(result, '_moduleSetUpFailed', False):
+                if getattr(test.__class__, "_classSetupFailed", False) or getattr(
+                    result, "_moduleSetUpFailed", False
+                ):
                     continue
 
             if not debug:
@@ -56,7 +57,7 @@ def run(self, result, debug=False):
             result._testRunEntered = False
 
     def _handleClassSetUp(self, test, result):
-        previousClass = getattr(result, '_previousTestClass', None)
+        previousClass = getattr(result, "_previousTestClass", None)
         currentClass = test.__class__
         if currentClass == previousClass:
             return
@@ -72,9 +73,9 @@ def _handleClassSetUp(self, test, result):
             # so its class will be a builtin-type
             pass
 
-        setUpClass = getattr(currentClass, 'setUpClass', None)
+        setUpClass = getattr(currentClass, "setUpClass", None)
         if setUpClass is not None:
-            _call_if_exists(result, '_setupStdout')
+            _call_if_exists(result, "_setupStdout")
             try:
                 deferred = setUpClass()
                 if isinstance(deferred, DeferrableMethod):
@@ -84,26 +85,26 @@ def _handleClassSetUp(self, test, result):
                     raise
                 currentClass._classSetupFailed = True
                 className = util.strclass(currentClass)
-                errorName = 'setUpClass (%s)' % className
+                errorName = "setUpClass (%s)" % className
                 self._addClassOrModuleLevelException(result, e, errorName)
             finally:
-                _call_if_exists(result, '_restoreStdout')
+                _call_if_exists(result, "_restoreStdout")
 
     def _tearDownPreviousClass(self, test, result):
-        previousClass = getattr(result, '_previousTestClass', None)
+        previousClass = getattr(result, "_previousTestClass", None)
         currentClass = test.__class__
         if currentClass == previousClass:
             return
-        if getattr(previousClass, '_classSetupFailed', False):
+        if getattr(previousClass, "_classSetupFailed", False):
             return
-        if getattr(result, '_moduleSetUpFailed', False):
+        if getattr(result, "_moduleSetUpFailed", False):
             return
         if getattr(previousClass, "__unittest_skip__", False):
             return
 
-        tearDownClass = getattr(previousClass, 'tearDownClass', None)
+        tearDownClass = getattr(previousClass, "tearDownClass", None)
         if tearDownClass is not None:
-            _call_if_exists(result, '_setupStdout')
+            _call_if_exists(result, "_setupStdout")
             try:
                 deferred = tearDownClass()
                 if isinstance(deferred, DeferrableMethod):
@@ -112,7 +113,7 @@ def _tearDownPreviousClass(self, test, result):
                 if isinstance(result, _DebugResult):
                     raise
                 className = util.strclass(previousClass)
-                errorName = 'tearDownClass (%s)' % className
+                errorName = "tearDownClass (%s)" % className
                 self._addClassOrModuleLevelException(result, e, errorName)
             finally:
-                _call_if_exists(result, '_restoreStdout')
+                _call_if_exists(result, "_restoreStdout")

unittesting/core/py38/case.py

@@ -7,10 +7,7 @@
 
 from .runner import defer
 
-__all__ = [
-    "DeferrableTestCase",
-    "expectedFailure"
-]
+__all__ = ["DeferrableTestCase", "expectedFailure"]
 
 
 class DeferrableTestCase(TestCase):
@@ -43,27 +40,29 @@ def run(self, result=None):
         orig_result = result
         if result is None:
             result = self.defaultTestResult()
-            startTestRun = getattr(result, 'startTestRun', None)
+            startTestRun = getattr(result, "startTestRun", None)
             if startTestRun is not None:
                 startTestRun()
 
         result.startTest(self)
 
         testMethod = getattr(self, self._testMethodName)
-        if (getattr(self.__class__, "__unittest_skip__", False) or
-                getattr(testMethod, "__unittest_skip__", False)):
+        if getattr(self.__class__, "__unittest_skip__", False) or getattr(
+            testMethod, "__unittest_skip__", False
+        ):
             # If the class or method was skipped.
             try:
-                skip_why = (getattr(self.__class__, '__unittest_skip_why__', '')
-                            or getattr(testMethod, '__unittest_skip_why__', ''))
+                skip_why = getattr(
+                    self.__class__, "__unittest_skip_why__", ""
+                ) or getattr(testMethod, "__unittest_skip_why__", "")
                 self._addSkip(result, self, skip_why)
             finally:
                 result.stopTest(self)
             return
-        expecting_failure_method = getattr(testMethod,
-                                           "__unittest_expecting_failure__", False)
-        expecting_failure_class = getattr(self,
-                                          "__unittest_expecting_failure__", False)
+        expecting_failure_method = getattr(
+            testMethod, "__unittest_expecting_failure__", False
+        )
+        expecting_failure_class = getattr(self, "__unittest_expecting_failure__", False)
         expecting_failure = expecting_failure_class or expecting_failure_method
         outcome = _Outcome(result)
         try:
@@ -103,7 +102,7 @@ def run(self, result=None):
         finally:
             result.stopTest(self)
             if orig_result is None:
-                stopTestRun = getattr(result, 'stopTestRun', None)
+                stopTestRun = getattr(result, "stopTestRun", None)
                 if stopTestRun is not None:
                     stopTestRun()