🔧 mypy fixes

pyproject.toml

@@ -99,7 +99,6 @@ exclude = [
   "^sphinxcontrib/test_reports/exceptions\\.py$",
   "^sphinxcontrib/test_reports/functions",
   "^sphinxcontrib/test_reports/jsonparser\\.py$",
-  "^sphinxcontrib/test_reports/junitparser\\.py$",
   "^sphinxcontrib/test_reports/test_reports\\.py$",
 ]
 # Disallow dynamic typing

sphinxcontrib/test_reports/directives/test_case.py

@@ -7,6 +7,8 @@
 from sphinxcontrib.test_reports.directives.test_common import TestCommonDirective
 from sphinxcontrib.test_reports.exceptions import TestReportInvalidOptionError
 
+from typing import Dict, List, Optional, Match, Tuple, cast
+
 
 class TestCase(nodes.General, nodes.Element):
     pass
@@ -34,133 +36,141 @@ class TestCaseDirective(TestCommonDirective):
 
     final_argument_whitespace = True
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args: object, **kwargs: object) -> None:
         super().__init__(*args, **kwargs)
 
-    def run(self, nested=False, suite_count=-1, case_count=-1):
+    def run(self, nested: bool = False, suite_count: int = -1, case_count: int = -1) -> List[nodes.Element]:
         self.prepare_basic_options()
-        self.load_test_file()
-
-        if nested and suite_count >= 0:
-            # access n-th nested suite here
-            self.results = self.results[0]["testsuites"][suite_count]
-
-        suite_name = self.options.get("suite")
+        results = self.load_test_file()
 
+        suite_name = cast(Optional[str], self.options.get("suite"))
         if suite_name is None:
             raise TestReportInvalidOptionError("Suite not given!")
 
-        case_full_name = self.options.get("case")
-        class_name = self.options.get("classname")
+        case_full_name = cast(Optional[str], self.options.get("case"))
+        class_name = cast(Optional[str], self.options.get("classname"))
         if case_full_name is None and class_name is None:
             raise TestReportInvalidOptionError("Case or classname not given!")
 
-        suite = None
-        for suite_obj in self.results:
-            if nested:  # nested testsuites
-                suite = self.results
-                break
-
-            elif suite_obj["name"] == suite_name:
-                suite = suite_obj
-                break
-
-        if suite is None:
+        # Typing aliases
+        TestsuiteDict = Dict[str, object]
+        TestcaseDict = Dict[str, object]
+
+        # Gather candidate suites
+        candidate_suites: List[TestsuiteDict] = []
+        if results is not None:
+            candidate_suites = cast(List[TestsuiteDict], results)
+
+        # Handle nested selection if requested
+        selected_suite: Optional[TestsuiteDict] = None
+        if nested and suite_count >= 0 and candidate_suites:
+            root_suite = candidate_suites[0]
+            nested_suites = cast(List[TestsuiteDict], root_suite.get("testsuites", []))
+            if 0 <= suite_count < len(nested_suites):
+                selected_suite = nested_suites[suite_count]
+
+        # If not nested, search suite by name
+        if selected_suite is None:
+            for suite_obj in candidate_suites:
+                if str(suite_obj.get("name", "")) == suite_name:
+                    selected_suite = suite_obj
+                    break
+
+        if selected_suite is None:
             raise TestReportInvalidOptionError(
                 f"Suite {suite_name} not found in test file {self.test_file}"
             )
 
-        case = None
-
-        for case_obj in suite["testcases"]:
-            if case_obj["name"] == case_full_name and class_name is None:  # noqa: SIM114  # noqa: W503
-                case = case_obj
+        # Select testcase
+        testcases = cast(List[TestcaseDict], selected_suite.get("testcases", []))
+        selected_case: Optional[TestcaseDict] = None
+        for case_obj in testcases:
+            name = str(case_obj.get("name", ""))
+            classname_val = str(case_obj.get("classname", ""))
+            if name == (case_full_name or "") and class_name is None:
+                selected_case = case_obj
                 break
-
-            elif (case_obj["classname"] == class_name and case_full_name is None) or (
-                case_obj["name"] == case_full_name
-                and case_obj["classname"] == class_name
+            elif (classname_val == (class_name or "") and case_full_name is None) or (
+                name == (case_full_name or "") and classname_val == (class_name or "")
             ):
-                case = case_obj
+                selected_case = case_obj
                 break
 
-            elif nested and case_count >= 0:
-                # access correct case in list
-                case = suite["testcases"][case_count]
-                break
+        if selected_case is None and nested and case_count >= 0 and 0 <= case_count < len(testcases):
+            selected_case = testcases[case_count]
 
-            elif nested:
-                case = case_obj
-                break
+        if selected_case is None and nested and testcases:
+            selected_case = testcases[0]
 
-        if case is None:
+        if selected_case is None:
             raise TestReportInvalidOptionError(
                 f"Case {case_full_name} with classname {class_name} not found in test file {self.test_file} "
                 f"and testsuite {suite_name}"
             )
 
-        result = case["result"]
-        content = self.test_content
-        if case["text"] is not None and len(case["text"]) > 0:
+        result = str(selected_case.get("result", ""))
+        content = self.test_content or ""
+        if selected_case.get("text") is not None and isinstance(selected_case.get("text"), str) and len(cast(str, selected_case.get("text"))) > 0:
             content += """
 
 **Text**::
 
    {}
 
-""".format("\n   ".join([x.lstrip() for x in case["text"].split("\n")]))
+""".format("\n   ".join([x.lstrip() for x in cast(str, selected_case.get("text", "")).split("\n")]))
 
-        if case["message"] is not None and len(case["message"]) > 0:
+        if selected_case.get("message") is not None and isinstance(selected_case.get("message"), str) and len(cast(str, selected_case.get("message"))) > 0:
             content += """
 
 **Message**::
 
    {}
 
-""".format("\n   ".join([x.lstrip() for x in case["message"].split("\n")]))
+""".format("\n   ".join([x.lstrip() for x in cast(str, selected_case.get("message", "")).split("\n")]))
 
-        if case["system-out"] is not None and len(case["system-out"]) > 0:
+        if selected_case.get("system-out") is not None and isinstance(selected_case.get("system-out"), str) and len(cast(str, selected_case.get("system-out"))) > 0:
             content += """
 
 **System-out**::
 
    {}
 
-""".format("\n   ".join([x.lstrip() for x in case["system-out"].split("\n")]))
+""".format("\n   ".join([x.lstrip() for x in cast(str, selected_case.get("system-out", "")).split("\n")]))
 
-        time = case["time"]
-        style = "tr_" + case["result"]
+        time = float(selected_case.get("time", 0.0))
+        style = "tr_" + str(selected_case.get("result", ""))
 
         import re
 
-        groups = re.match(r"^(?P<name>[^\[]+)($|\[(?P<param>.*)?\])", case["name"])
-        try:
+        groups: Optional[Match[str]] = re.match(r"^(?P<name>[^\[]+)($|\[(?P<param>.*)?\])", str(selected_case.get("name", "")))
+        if groups is not None:
             case_name = groups["name"]
             case_parameter = groups["param"]
-        except TypeError:
+        else:
             case_name = case_full_name
             case_parameter = ""
 
         if case_parameter is None:
             case_parameter = ""
 
         # Set extra data, which is not part of the Sphinx-Test-Reports default options
-        for key, value in case.items():
+        for key, value in selected_case.items():
             if key == "id" and value not in ["", None]:
                 self.test_id = str(value)
             elif key == "status" and value not in ["", None]:
                 self.test_status = str(value)
             elif key == "tags":
-                self.test_tags = ",".join([self.test_tags, str(value)])
+                self.test_tags = ",".join([self.test_tags or "", str(value)])
             elif key not in DEFAULT_OPTIONS and value not in ["", None]:
                 # May overwrite globally set values
-                self.extra_options[key] = str(value)
+                if self.extra_options is not None:
+                    self.extra_options[key] = str(value)
 
-        docname = self.state.document.settings.env.docname
+        docname = cast(str, self.state.document.settings.env.docname)
 
-        main_section = []
+        main_section: List[nodes.Element] = []
         # Merge all options including extra ones
-        main_section += add_need(
+        main_section += cast(List[nodes.Element], add_need(
             self.app,
             self.state,
             docname,
@@ -174,16 +184,16 @@ def run(self, nested=False, suite_count=-1, case_count=-1):
             status=self.test_status,
             collapse=self.collapse,
             file=self.test_file_given,
-            suite=suite["name"],
+            suite=str(selected_suite.get("name", "")),
             case=case_full_name,
             case_name=case_name,
             case_parameter=case_parameter,
             classname=class_name,
             result=result,
             time=time,
             style=style,
-            **self.extra_options,
-        )
+            **(self.extra_options or {}),
+        ))
 
         add_doc(self.env, docname)
         return main_section