Add better logging when failing to load a test.

typ/runner.py

 # Copyright 2014 Google Inc. All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #    http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 327 matching lines @@
         try:
             names = self._name_list_from_args(args)
             classifier = self.classifier or _default_classifier(args)
 
             for name in names:
                 try:
                     self._add_tests_to_set(test_set, args.suffixes,
                                            self.top_level_dir, classifier,
                                            name)
                 except (AttributeError, ImportError, SyntaxError) as e:
-                    self.print_('Failed to load "%s": %s' % (name, e))
+                    ex_str = traceback.format_exc()
+                    self.print_('Failed to load "%s" in find_tests: %s' %
+                                (name, e))
+                    self.print_('  %s' %
+                                '\n  '.join(ex_str.splitlines()))
+                    self.print_(ex_str)
                     return 1, None
                 except _AddTestsError as e:
                     self.print_(str(e))
                     return 1, None
 
             # TODO: Add support for discovering setupProcess/teardownProcess?
 
             shard_index = args.shard_index
             total_shards = args.total_shards
             assert total_shards >= 1
@@ skipping 43 matching lines @@
             possible_dir = name.replace('.', h.sep)
             if h.isdir(top_level_dir, possible_dir):
                 for suffix in suffixes:
                     path = h.join(top_level_dir, possible_dir)
                     suite = loader.discover(path, suffix, top_level_dir)
                     add_tests(suite)
             else:
                 add_tests(loader.loadTestsFromName(name))
 
         # pylint: disable=no-member
-        if hasattr(loader, 'errors') and loader.errors:
+        if hasattr(loader, 'errors') and loader.errors:  # pragma: python3
             # In Python3's version of unittest, loader failures get converted
             # into failed test cases, rather than raising exceptions. However,
             # the errors also get recorded so you can err out immediately.
             raise ImportError(loader.errors)
 
     def _run_tests(self, result_set, test_set):
         h = self.host
         if not test_set.parallel_tests and not test_set.isolated_tests:
             self.print_('No tests to run.')
             return 1, None
@@ skipping 376 matching lines @@
 
     # It is important to capture the output before loading the test
     # to ensure that
     # 1) the loader doesn't logs something we don't captured
     # 2) neither the loader nor the test case grab a reference to the
     #    uncaptured stdout or stderr that later is used when the test is run.
     # This comes up when using the FakeTestLoader and testing typ itself,
     # but could come up when testing non-typ code as well.
     h.capture_output(divert=not child.passthrough)
 
-    tb_str = ''
+    ex_str = ''
     try:
         orig_skip = unittest.skip
         orig_skip_if = unittest.skipIf
         if child.all:
             unittest.skip = lambda reason: lambda x: x
             unittest.skipIf = lambda condition, reason: lambda x: x
 
         try:
             suite = child.loader.loadTestsFromName(test_name)
         except Exception as e:
+            ex_str = ('loadTestsFromName("%s") failed: %s\n%s\n' %
+                      (test_name, e, traceback.format_exc()))
             try:
                 suite = _load_via_load_tests(child, test_name)
+                ex_str += ('\nload_via_load_tests(\"%s\") returned %d tests\n' %
+                           (test_name, len(list(suite))))
             except Exception as e:  # pragma: untested
                 suite = []
-                tb_str = traceback.format_exc(e)
+                ex_str += ('\nload_via_load_tests("%s") failed: %s\n%s\n' %
+                           (test_name, e, traceback.format_exc()))
     finally:
         unittest.skip = orig_skip
         unittest.skipIf = orig_skip_if
 
     tests = list(suite)
     if len(tests) != 1:
-        err = 'Failed to load %s' % test_name
-        if tb_str:  # pragma: untested
-            err += (' (traceback follows):\n  %s' %
-                    '  \n'.join(tb_str.splitlines()))
+        err = 'Failed to load "%s" in run_one_test' % test_name
+        if ex_str:  # pragma: untested
+            err += '\n  ' + '\n  '.join(ex_str.splitlines())
 
         h.restore_output()
         return Result(test_name, ResultType.Failure, start, 0,
                       child.worker_num, unexpected=True, code=1,
                       err=err, pid=pid)
 
     test_case = tests[0]
     if isinstance(test_case, TypTestCase):
         test_case.child = child
         test_case.context = child.context_after_setup
@@ skipping 86 matching lines @@
                 module = importlib.import_module(name)
             except ImportError:
                 pass
             if module:
                 suite = loader.loadTestsFromModule(module)
             child.loaded_suites[name] = suite
         suite = child.loaded_suites[name]
         if suite:
             for test_case in suite:
                 assert isinstance(test_case, unittest.TestCase)
-                if test_case.id() == test_name:
+                if test_case.id() == test_name:  # pragma: untested
                     new_suite.addTest(test_case)
                     break
         comps.pop()
     return new_suite
 
 
 def _sort_inputs(inps):
     return sorted(inps, key=lambda inp: inp.name)
 
 
 if __name__ == '__main__':  # pragma: no cover
     sys.modules['__main__'].__file__ = path_to_file
     sys.exit(main(win_multiprocessing=WinMultiprocessing.importable))