Add minimal type signatures to test scripts

An observed behavior is that mypy will not type signature analysis until
one is added in the call path, e.g. designating `def main() -> None`.
This patch is the minimal set of effects of adding a None return type to
unit test functions.

References:
* [AC-211] Add static type checking to CASE-Utilities-Python

Signed-off-by: Alex Nelson <alexander.nelson@nist.gov>

Author: ajnelson-nist

tests/case_file/test_case_file.py

@@ -37,20 +37,22 @@
 
 SRCDIR = os.path.dirname(__file__)
 
-def load_graph(filename):
+def load_graph(
+  filename
+) -> rdflib.Graph:
     in_graph = rdflib.Graph()
     in_graph.parse(filename)
     return in_graph
 
 @pytest.fixture
-def graph_case_file():
+def graph_case_file() -> rdflib.Graph:
     return load_graph(os.path.join(SRCDIR, "sample.txt.ttl"))
 
 @pytest.fixture
-def graph_case_file_disable_hashes():
+def graph_case_file_disable_hashes() -> rdflib.Graph:
     return load_graph(os.path.join(SRCDIR, "sample.txt-disable_hashes.ttl"))
 
-def test_confirm_hashes(graph_case_file):
+def test_confirm_hashes(graph_case_file) -> None:
     expected = {
       "MD5": "098F6BCD4621D373CADE4E832627B4F6",
       "SHA1": "A94A8FE5CCB19BA61C4C0873D391E987982FBBD3",
@@ -91,7 +93,7 @@ def test_confirm_hashes(graph_case_file):
 
     assert expected == computed
 
-def test_confirm_mtime(graph_case_file, graph_case_file_disable_hashes):
+def test_confirm_mtime(graph_case_file, graph_case_file_disable_hashes) -> None:
     query_confirm_mtime = """
 SELECT ?nFile
 WHERE {

tests/case_sparql_construct/test_case_sparql_construct.py

@@ -11,16 +11,18 @@
 #
 # We would appreciate acknowledgement if the software is used.
 
+import typing
+
 import rdflib.plugins.sparql  # type: ignore
 
 import case_utils
 
-def _test_templates_with_blank_nodes_result(filename):
+def _test_templates_with_blank_nodes_result(filename) -> None:
     ground_truth_positive = {
       ("Alice", "Hacker"),
       ("Bob", "Hacker")
     }
-    ground_truth_negative = set()
+    ground_truth_negative : typing.Set[str] = set()
 
     graph = rdflib.Graph()
     graph.parse(filename)
@@ -48,7 +50,8 @@ def _test_templates_with_blank_nodes_result(filename):
         ))
     assert computed == ground_truth_positive
 
-def test_templates_with_blank_nodes_result_json():
+def test_templates_with_blank_nodes_result_json() -> None:
     _test_templates_with_blank_nodes_result("output.json")
-def test_templates_with_blank_nodes_result_turtle():
+
+def test_templates_with_blank_nodes_result_turtle() -> None:
     _test_templates_with_blank_nodes_result("output.ttl")

tests/case_utils/test_guess_format.py

@@ -22,45 +22,45 @@
 PATH_TO_XHTML = "/nonexistent/foo.xhtml"
 FMAP_XHTML_GRDDL = {"xhtml": "grddl"}
 
-def test_rdflib_util_guess_format_xhtml_default():
+def test_rdflib_util_guess_format_xhtml_default() -> None:
     assert rdflib.util.guess_format(PATH_TO_XHTML) == "rdfa", "Failed to reproduce rdflib.util.guess_format test"
 
-def test_rdflib_util_guess_format_xhtml_fmap():
+def test_rdflib_util_guess_format_xhtml_fmap() -> None:
     """
     This test implements one of the documented demonstrations in rdflib.util.guess_format.
     """
     assert rdflib.util.guess_format(PATH_TO_XHTML, FMAP_XHTML_GRDDL) == "grddl", "Failed to reproduce rdflib.util.guess_format test"
 
-def test_rdflib_util_guess_format_ttl_default():
+def test_rdflib_util_guess_format_ttl_default() -> None:
     assert rdflib.util.guess_format(PATH_TO_TTL) == "turtle", "Failed to recognize .ttl RDF file extension"
 
 @pytest.mark.xfail(reason="rdflib 5.0.0 guess_format fmap argument overwrites base module's extension map", strict=True)
-def test_rdflib_util_guess_format_ttl_fmap():
+def test_rdflib_util_guess_format_ttl_fmap() -> None:
     assert rdflib.util.guess_format(PATH_TO_TTL, FMAP_XHTML_GRDDL) == "turtle", "Failed to recognize .ttl RDF file extension when using fmap"
 
-def test_rdflib_util_guess_format_json():
+def test_rdflib_util_guess_format_json() -> None:
     assert rdflib.util.guess_format(PATH_TO_JSON) == "json-ld", "Failed to recognize .json RDF file extension"
 
-def test_rdflib_util_guess_format_jsonld():
+def test_rdflib_util_guess_format_jsonld() -> None:
     assert rdflib.util.guess_format(PATH_TO_JSONLD) == "json-ld", "Failed to recognize .jsonld RDF file extension"
 
-def test_case_utils_guess_format_ttl_default():
+def test_case_utils_guess_format_ttl_default() -> None:
     assert case_utils.guess_format(PATH_TO_TTL) == "turtle", "Failed to recognize .ttl RDF file extension"
 
 @pytest.mark.xfail(reason="Preserving behavior - rdflib 5.0.0 guess_format fmap argument overwrites base module's extension map", strict=True)
-def test_case_utils_guess_format_ttl_fmap():
+def test_case_utils_guess_format_ttl_fmap() -> None:
     assert case_utils.guess_format(PATH_TO_TTL, FMAP_XHTML_GRDDL) == "turtle", "Failed to recognize .ttl RDF file extension when using fmap"
 
-def test_case_utils_guess_format_json_default():
+def test_case_utils_guess_format_json_default() -> None:
     assert case_utils.guess_format(PATH_TO_JSON) == "json-ld", "Failed to recognize .json RDF file extension"
 
 @pytest.mark.xfail(reason="Preserving behavior - rdflib 5.0.0 guess_format fmap argument overwrites base module's extension map", strict=True)
-def test_case_utils_guess_format_json_fmap():
+def test_case_utils_guess_format_json_fmap() -> None:
     assert case_utils.guess_format(PATH_TO_JSON, FMAP_XHTML_GRDDL) == "json-ld", "Failed to recognize .json RDF file extension when using fmap"
 
-def test_case_utils_guess_format_jsonld_default():
+def test_case_utils_guess_format_jsonld_default() -> None:
     assert case_utils.guess_format(PATH_TO_JSONLD) == "json-ld", "Failed to recognize .jsonld RDF file extension"
 
 @pytest.mark.xfail(reason="Preserving behavior - rdflib 5.0.0 guess_format fmap argument overwrites base module's extension map", strict=True)
-def test_case_utils_guess_format_jsonld_fmap():
+def test_case_utils_guess_format_jsonld_fmap() -> None:
     assert case_utils.guess_format(PATH_TO_JSONLD, FMAP_XHTML_GRDDL) == "json-ld", "Failed to recognize .jsonld RDF file extension when using fmap"

tests/hexbinary/test_hexbinary.py

@@ -48,6 +48,7 @@
 
 import logging
 import os
+import typing
 
 import pytest
 import rdflib.plugins.sparql  # type: ignore
@@ -64,7 +65,7 @@
 n_uppercase1 = rdflib.URIRef("urn:example:uppercase1")
 p_predicate = rdflib.URIRef("urn:example:predicate1")
 
-def test_sparql_syntax_bind_boolean():
+def test_sparql_syntax_bind_boolean() -> None:
     """
     This test serves as a syntax reminder for binding boolean values.
     """
@@ -81,7 +82,7 @@ def test_sparql_syntax_bind_boolean():
     assert confirmed
 
 @pytest.mark.xfail(reason="hard-coded failure")
-def test_pytest_syntax_xfail():
+def test_pytest_syntax_xfail() -> None:
     """
     This test serves as a syntax reminder for the XFail decorator.
     """
@@ -97,7 +98,7 @@ def test_pytest_syntax_xfail():
         confirmed = l_value.toPython()
     assert confirmed
 
-def test_sparql_syntax_integer_coercion():
+def test_sparql_syntax_integer_coercion() -> None:
     """
     This test serves as a syntax reminder for type coercions.
     """
@@ -113,7 +114,7 @@ def test_sparql_syntax_integer_coercion():
         confirmed = l_value.toPython()
     assert confirmed
 
-def test_sparql_syntax_integer_cast():
+def test_sparql_syntax_integer_cast() -> None:
     """
     This test serves as a syntax reminder for the casting form of type coercions.
     """
@@ -130,7 +131,7 @@ def test_sparql_syntax_integer_cast():
     assert confirmed
 
 @pytest.mark.xfail
-def test_sparql_cast_custom_type():
+def test_sparql_cast_custom_type() -> None:
     """
     This test checks for nonexistent literal-datatype assignments.
     """
@@ -146,7 +147,7 @@ def test_sparql_cast_custom_type():
         confirmed = l_value.toPython()
     assert confirmed
 
-def test_sparql_compare_hexbinary_mixcase():
+def test_sparql_compare_hexbinary_mixcase() -> None:
     confirmed = None
     graph = rdflib.Graph()
     for result in graph.query("""\
@@ -159,7 +160,7 @@ def test_sparql_compare_hexbinary_mixcase():
         confirmed = l_value.toPython()
     assert confirmed
 
-def test_sparql_compare_hexbinary_matchcase():
+def test_sparql_compare_hexbinary_matchcase() -> None:
     confirmed = None
     graph = rdflib.Graph()
     for result in graph.query("""\
@@ -172,7 +173,7 @@ def test_sparql_compare_hexbinary_matchcase():
         confirmed = l_value.toPython()
     assert confirmed
 
-def test_sparql_compare_hexbinarycanonical_matchcase():
+def test_sparql_compare_hexbinarycanonical_matchcase() -> None:
     confirmed = None
     graph = rdflib.Graph()
     for result in graph.query("""\
@@ -186,7 +187,7 @@ def test_sparql_compare_hexbinarycanonical_matchcase():
     assert confirmed
 
 @pytest.mark.xfail
-def test_sparql_compare_hexbinarycanonical_mixcase():
+def test_sparql_compare_hexbinarycanonical_mixcase() -> None:
     """
     This test shows hexBinaryCanonical does not induce a casing-insensitive comparison.
     """
@@ -203,7 +204,7 @@ def test_sparql_compare_hexbinarycanonical_mixcase():
     assert confirmed
 
 @pytest.mark.xfail
-def test_sparql_compare_hb_hbc_mixcase():
+def test_sparql_compare_hb_hbc_mixcase() -> None:
     """
     This test confirms that literal-comparison takes into account datatype when one type is unknown.
     """
@@ -220,7 +221,7 @@ def test_sparql_compare_hb_hbc_mixcase():
     assert confirmed
 
 @pytest.mark.xfail
-def test_sparql_compare_hb_hbc_mixcase_cast():
+def test_sparql_compare_hb_hbc_mixcase_cast() -> None:
     """
     This test is a bit redundant with test_sparql_cast_custom_type, but is here as an explicit demonstration of failure to cast a hexBinary value.
     """
@@ -236,7 +237,7 @@ def test_sparql_compare_hb_hbc_mixcase_cast():
         confirmed = l_value.toPython()
     assert confirmed
 
-def test_rdflib_literal_hexbinary():
+def test_rdflib_literal_hexbinary() -> None:
     _logger.debug("l_hb_lowercase = %r." % l_hb_lowercase)
     _logger.debug("l_hb_uppercase = %r." % l_hb_uppercase)
     _logger.debug("l_hb_lowercase.toPython() = %r." % l_hb_lowercase.toPython())
@@ -249,20 +250,20 @@ def test_rdflib_literal_hexbinary():
     assert l_hb_lowercase.toPython() == l_hb_uppercase.toPython()
 
 @pytest.mark.xfail
-def test_rdflib_literal_hexbinarycanonical():
+def test_rdflib_literal_hexbinarycanonical() -> None:
     _logger.debug("l_hb_uppercase = %r." % l_hb_uppercase)
     _logger.debug("l_hbc_uppercase = %r." % l_hbc_uppercase)
 
     assert l_hb_uppercase == l_hbc_uppercase
 
 @pytest.mark.xfail
-def test_rdflib_literal_topython_hexbinarycanonical():
+def test_rdflib_literal_topython_hexbinarycanonical() -> None:
     _logger.debug("l_hb_lowercase.toPython() = %r." % l_hb_lowercase.toPython())
     _logger.debug("l_hb_uppercase.toPython() = %r." % l_hb_uppercase.toPython())
 
     assert l_hb_uppercase.toPython() == l_hbc_uppercase.toPython()
 
-def _query_all_value_matches(graph):
+def _query_all_value_matches(graph) -> typing.Set[str]:
     """
     Return set of all node names (as strings) that have a matching value, where
     "matching" is determined by the SPARQL engine's type and data coercions.
@@ -280,7 +281,7 @@ def _query_all_value_matches(graph):
         computed.add(n_node2.toPython())
     return computed
 
-def test_graph_repeat():
+def test_graph_repeat() -> None:
     """
     Two nodes are given the same literal value, and are found to match on literal values.
     """
@@ -302,7 +303,7 @@ def test_graph_repeat():
     computed = _query_all_value_matches(graph)
     assert computed == expected
 
-def test_graph_all_hexbinary_literals():
+def test_graph_all_hexbinary_literals() -> None:
     """
     Two nodes with the same literal value, and another node with the uppercase of the literal hexBinary value, are found to match on literal values.
     """
@@ -333,7 +334,7 @@ def test_graph_all_hexbinary_literals():
     assert computed == expected
 
 @pytest.mark.xfail
-def test_graph_hexbinarycanonical():
+def test_graph_hexbinarycanonical() -> None:
     graph = rdflib.Graph()
     graph.add((
       n_lowercase1,

tests/src/compact.py

@@ -28,7 +28,7 @@
 
 _logger = logging.getLogger(os.path.basename(__file__))
 
-def main():
+def main() -> None:
     with open(args.out_json, "w") as out_fh:
         doc = None
         with open(args.in_json, "r") as in_fh:

tests/src/glom_graph.py

@@ -21,7 +21,7 @@
 
 import case_utils
 
-def main():
+def main() -> None:
     g = rdflib.Graph()
     for in_graph in args.in_graph:
         g.parse(in_graph)

tests/src/isomorphic_diff.py

@@ -40,7 +40,7 @@
 
 _logger = logging.getLogger(os.path.basename(__file__))
 
-def main():
+def main() -> None:
     parser = argparse.ArgumentParser()
     parser.add_argument("--debug", action="store_true")
     parser.add_argument("in_graph_1")