mypy: test_goldtest.py test_json.py test_lcov.py test_mixins.py test_numbits.py test_oddball.py

Author: nedbat

tests/test_goldtest.py

@@ -3,6 +3,8 @@
 
 """Tests of the helpers in goldtest.py"""
 
+from __future__ import annotations
+
 import os.path
 import re
 
@@ -33,7 +35,7 @@
     (r'G\w+', 'Gxxx'),
 ]
 
-def path_regex(path):
+def path_regex(path: str) -> str:
     """Convert a file path into a regex that will match that path on any OS."""
     return re.sub(r"[/\\]", r"[/\\\\]", path.replace(".", "[.]"))
 
@@ -48,16 +50,16 @@ def path_regex(path):
 class CompareTest(CoverageTest):
     """Tests of goldtest.py:compare()"""
 
-    def setUp(self):
+    def setUp(self) -> None:
         super().setUp()
         self.addCleanup(remove_tree, ACTUAL_DIR)
 
-    def test_good(self):
+    def test_good(self) -> None:
         self.make_file("out/gettysburg.txt", GOOD_GETTY)
         compare(gold_path("testing/getty"), "out", scrubs=SCRUBS)
         self.assert_doesnt_exist(ACTUAL_GETTY_FILE)
 
-    def test_bad(self):
+    def test_bad(self) -> None:
         self.make_file("out/gettysburg.txt", BAD_GETTY)
 
         # compare() raises an assertion.
@@ -78,7 +80,7 @@ def test_bad(self):
             saved = f.read()
         assert saved == BAD_GETTY
 
-    def test_good_needs_scrubs(self):
+    def test_good_needs_scrubs(self) -> None:
         # Comparing the "good" result without scrubbing the variable parts will fail.
         self.make_file("out/gettysburg.txt", GOOD_GETTY)
 
@@ -91,7 +93,7 @@ def test_good_needs_scrubs(self):
         assert "- 11/19/1863, Gettysburg, Pennsylvania" in stdout
         assert "+ 11/19/9999, Gettysburg, Pennsylvania" in stdout
 
-    def test_actual_extra(self):
+    def test_actual_extra(self) -> None:
         self.make_file("out/gettysburg.txt", GOOD_GETTY)
         self.make_file("out/another.more", "hi")
 
@@ -107,7 +109,7 @@ def test_actual_extra(self):
         # But only the files matching the file_pattern are considered.
         compare(gold_path("testing/getty"), "out", file_pattern="*.txt", scrubs=SCRUBS)
 
-    def test_xml_good(self):
+    def test_xml_good(self) -> None:
         self.make_file("out/output.xml", """\
             <?xml version="1.0" ?>
             <the_root c="three" b="222" a="one">
@@ -118,7 +120,7 @@ def test_xml_good(self):
             """)
         compare(gold_path("testing/xml"), "out", scrubs=SCRUBS)
 
-    def test_xml_bad(self):
+    def test_xml_bad(self) -> None:
         self.make_file("out/output.xml", """\
             <?xml version="1.0" ?>
             <the_root c="nine" b="2" a="one">
@@ -147,25 +149,25 @@ class ContainsTest(CoverageTest):
 
     run_in_temp_dir = False
 
-    def test_contains(self):
+    def test_contains(self) -> None:
         contains(GOLD_GETTY_FILE, "Four", "fathers", "dedicated")
         msg = rf"Missing content in {GOLD_GETTY_FILE_RX}: 'xyzzy'"
         with pytest.raises(AssertionError, match=msg):
             contains(GOLD_GETTY_FILE, "Four", "fathers", "xyzzy", "dedicated")
 
-    def test_contains_rx(self):
+    def test_contains_rx(self) -> None:
         contains_rx(GOLD_GETTY_FILE, r"Fo.r", r"f[abc]thers", "dedi[cdef]ated")
         msg = rf"Missing regex in {GOLD_GETTY_FILE_RX}: r'm\[opq\]thers'"
         with pytest.raises(AssertionError, match=msg):
             contains_rx(GOLD_GETTY_FILE, r"Fo.r", r"m[opq]thers")
 
-    def test_contains_any(self):
+    def test_contains_any(self) -> None:
         contains_any(GOLD_GETTY_FILE, "Five", "Four", "Three")
         msg = rf"Missing content in {GOLD_GETTY_FILE_RX}: 'One' \[1 of 3\]"
         with pytest.raises(AssertionError, match=msg):
             contains_any(GOLD_GETTY_FILE, "One", "Two", "Three")
 
-    def test_doesnt_contain(self):
+    def test_doesnt_contain(self) -> None:
         doesnt_contain(GOLD_GETTY_FILE, "One", "Two", "Three")
         msg = rf"Forbidden content in {GOLD_GETTY_FILE_RX}: 'Four'"
         with pytest.raises(AssertionError, match=msg):

tests/test_json.py

@@ -2,17 +2,29 @@
 # For details: https://github.com/nedbat/coveragepy/blob/master/NOTICE.txt
 
 """Test json-based summary reporting for coverage.py"""
-from datetime import datetime
+
+from __future__ import annotations
+
 import json
 import os
 
+from datetime import datetime
+from typing import Any, Dict
+
 import coverage
+from coverage import Coverage
+
 from tests.coveragetest import UsingModulesMixin, CoverageTest
 
 
 class JsonReportTest(UsingModulesMixin, CoverageTest):
     """Tests of the JSON reports from coverage.py."""
-    def _assert_expected_json_report(self, cov, expected_result):
+
+    def _assert_expected_json_report(
+        self,
+        cov: Coverage,
+        expected_result: Dict[str, Any],
+    ) -> None:
         """
         Helper for tests that handles the common ceremony so the tests can be clearly show the
         consequences of setting various arguments.
@@ -39,7 +51,7 @@ def _assert_expected_json_report(self, cov, expected_result):
         del (parsed_result['meta']['timestamp'])
         assert parsed_result == expected_result
 
-    def test_branch_coverage(self):
+    def test_branch_coverage(self) -> None:
         cov = coverage.Coverage(branch=True)
         expected_result = {
             'meta': {
@@ -91,7 +103,7 @@ def test_branch_coverage(self):
         }
         self._assert_expected_json_report(cov, expected_result)
 
-    def test_simple_line_coverage(self):
+    def test_simple_line_coverage(self) -> None:
         cov = coverage.Coverage()
         expected_result = {
             'meta': {
@@ -125,7 +137,7 @@ def test_simple_line_coverage(self):
         }
         self._assert_expected_json_report(cov, expected_result)
 
-    def run_context_test(self, relative_files):
+    def run_context_test(self, relative_files: bool) -> None:
         """A helper for two tests below."""
         self.make_file("config", """\
             [run]
@@ -187,8 +199,8 @@ def run_context_test(self, relative_files):
         }
         self._assert_expected_json_report(cov, expected_result)
 
-    def test_context_non_relative(self):
+    def test_context_non_relative(self) -> None:
         self.run_context_test(relative_files=False)
 
-    def test_context_relative(self):
+    def test_context_relative(self) -> None:
         self.run_context_test(relative_files=True)

tests/test_lcov.py

@@ -3,6 +3,8 @@
 
 """Test LCOV-based summary reporting for coverage.py."""
 
+from __future__ import annotations
+
 import math
 import textwrap
 
@@ -15,7 +17,7 @@
 class LcovTest(CoverageTest):
     """Tests of the LCOV reports from coverage.py."""
 
-    def create_initial_files(self):
+    def create_initial_files(self) -> None:
         """
         Helper for tests that handles the common ceremony so the tests can
         show the consequences of changes in the setup.
@@ -44,13 +46,12 @@ def test_volume(self):
                     self.assertAlmostEqual(cuboid_volume(5.5),166.375)
             """)
 
-    def get_lcov_report_content(self, filename="coverage.lcov"):
+    def get_lcov_report_content(self, filename: str="coverage.lcov") -> str:
         """Return the content of an LCOV report."""
         with open(filename, "r") as file:
-            file_contents = file.read()
-        return file_contents
+            return file.read()
 
-    def test_lone_file(self):
+    def test_lone_file(self) -> None:
         """For a single file with a couple of functions, the lcov should cover
         the function definitions themselves, but not the returns."""
         self.make_file("main_file.py", """\
@@ -81,7 +82,7 @@ def IsItTrue():
         actual_result = self.get_lcov_report_content()
         assert expected_result == actual_result
 
-    def test_simple_line_coverage_two_files(self):
+    def test_simple_line_coverage_two_files(self) -> None:
         """Test that line coverage is created when coverage is run,
         and matches the output of the file below."""
         self.create_initial_files()
@@ -119,7 +120,7 @@ def test_simple_line_coverage_two_files(self):
         actual_result = self.get_lcov_report_content(filename="data.lcov")
         assert expected_result == actual_result
 
-    def test_branch_coverage_one_file(self):
+    def test_branch_coverage_one_file(self) -> None:
         """Test that the reporter produces valid branch coverage."""
         self.make_file("main_file.py", """\
             #!/usr/bin/env python3
@@ -154,7 +155,7 @@ def is_it_x(x):
         actual_result = self.get_lcov_report_content()
         assert expected_result == actual_result
 
-    def test_branch_coverage_two_files(self):
+    def test_branch_coverage_two_files(self) -> None:
         """Test that valid branch coverage is generated
         in the case of two files."""
         self.make_file("main_file.py", """\
@@ -215,7 +216,7 @@ def test_is_it_x(self):
         actual_result = self.get_lcov_report_content()
         assert actual_result == expected_result
 
-    def test_half_covered_branch(self):
+    def test_half_covered_branch(self) -> None:
         """Test that for a given branch that is only half covered,
         the block numbers remain the same, and produces valid lcov.
         """
@@ -251,7 +252,7 @@ def test_half_covered_branch(self):
         actual_result = self.get_lcov_report_content()
         assert actual_result == expected_result
 
-    def test_empty_init_files(self):
+    def test_empty_init_files(self) -> None:
         """Test that in the case of an empty __init__.py file, the lcov
         reporter will note that the file is there, and will note the empty
         line. It will also note the lack of branches, and the checksum for

tests/test_mixins.py

@@ -3,6 +3,8 @@
 
 """Tests of code in tests/mixins.py"""
 
+from __future__ import annotations
+
 import pytest
 
 from coverage.misc import import_local_file
@@ -13,12 +15,12 @@
 class TempDirMixinTest(TempDirMixin):
     """Test the methods in TempDirMixin."""
 
-    def file_text(self, fname):
+    def file_text(self, fname: str) -> str:
         """Return the text read from a file."""
         with open(fname, "rb") as f:
             return f.read().decode('ascii')
 
-    def test_make_file(self):
+    def test_make_file(self) -> None:
         # A simple file.
         self.make_file("fooey.boo", "Hello there")
         assert self.file_text("fooey.boo") == "Hello there"
@@ -38,21 +40,21 @@ def test_make_file(self):
             """)
         assert self.file_text("dedented.txt") == "Hello\nBye\n"
 
-    def test_make_file_newline(self):
+    def test_make_file_newline(self) -> None:
         self.make_file("unix.txt", "Hello\n")
         assert self.file_text("unix.txt") == "Hello\n"
         self.make_file("dos.txt", "Hello\n", newline="\r\n")
         assert self.file_text("dos.txt") == "Hello\r\n"
         self.make_file("mac.txt", "Hello\n", newline="\r")
         assert self.file_text("mac.txt") == "Hello\r"
 
-    def test_make_file_non_ascii(self):
+    def test_make_file_non_ascii(self) -> None:
         self.make_file("unicode.txt", "tablo: «ταБℓσ»")
         with open("unicode.txt", "rb") as f:
             text = f.read()
         assert text == b"tablo: \xc2\xab\xcf\x84\xce\xb1\xd0\x91\xe2\x84\x93\xcf\x83\xc2\xbb"
 
-    def test_make_bytes_file(self):
+    def test_make_bytes_file(self) -> None:
         self.make_file("binary.dat", bytes=b"\x99\x33\x66hello\0")
         with open("binary.dat", "rb") as f:
             data = f.read()
@@ -63,12 +65,12 @@ class RestoreModulessMixinTest(TempDirMixin, RestoreModulesMixin):
     """Tests of SysPathModulesMixin."""
 
     @pytest.mark.parametrize("val", [17, 42])
-    def test_module_independence(self, val):
+    def test_module_independence(self, val: int) -> None:
         self.make_file("xyzzy.py", f"A = {val}")
         import xyzzy            # pylint: disable=import-error
         assert xyzzy.A == val
 
-    def test_cleanup_and_reimport(self):
+    def test_cleanup_and_reimport(self) -> None:
         self.make_file("xyzzy.py", "A = 17")
         xyzzy = import_local_file("xyzzy")
         assert xyzzy.A == 17