fail_under can now be a float. #631.

3 files changed, 44 insertions, 25 deletions

diff --git a/tests/test_cmdline.py b/tests/test_cmdline.py
index 9d64d86..1b7c665 100644
--- a/tests/test_cmdline.py
+++ b/tests/test_cmdline.py
@@ -63,6 +63,11 @@ class BaseCmdLineTest(CoverageTest):
         config = CoverageConfig()
         mk.get_option = config.get_option
 
+        # Get the type right for the result of reporting.
+        mk.report.return_value = 50.0
+        mk.html_report.return_value = 50.0
+        mk.xml_report.return_value = 50.0
+
         return mk
 
     def mock_command_line(self, args, path_exists=None):
@@ -755,6 +760,7 @@ class CoverageReportingFake(object):
     """A fake Coverage and Coverage.coverage test double."""
     # pylint: disable=missing-docstring
     def __init__(self, report_result, html_result, xml_result):
+        self.config = CoverageConfig()
         self.report_result = report_result
         self.html_result = html_result
         self.xml_result = xml_result
@@ -763,10 +769,10 @@ class CoverageReportingFake(object):
         return self
 
     def set_option(self, optname, optvalue):
-        setattr(self, optname, optvalue)
+        self.config.set_option(optname, optvalue)
 
     def get_option(self, optname):
-        return getattr(self, optname)
+        return self.config.get_option(optname)
 
     def load(self):
         pass
@@ -801,7 +807,7 @@ class CoverageReportingFake(object):
 ])
 def test_fail_under(results, fail_under, cmd, ret):
     cov = CoverageReportingFake(*results)
-    if fail_under:
+    if fail_under is not None:
         cov.set_option("report:fail_under", fail_under)
     ret_actual = command_line(cmd, _covpkg=cov)
     assert ret_actual == ret
diff --git a/tests/test_process.py b/tests/test_process.py
index 2d4e72f..42a6d98 100644
--- a/tests/test_process.py
+++ b/tests/test_process.py
@@ -960,18 +960,22 @@ class FailUnderTest(CoverageTest):
             """)
         st, _ = self.run_command_status("coverage run forty_two_plus.py")
         self.assertEqual(st, 0)
-        st, out = self.run_command_status("coverage report")
-        self.assertEqual(st, 0)
-        self.assertEqual(
-            self.last_line_squeezed(out),
-            "forty_two_plus.py 7 4 43%"
-        )
 
-    def test_report(self):
-        st, _ = self.run_command_status("coverage report --fail-under=43")
+    def test_report_43_is_ok(self):
+        st, out = self.run_command_status("coverage report --fail-under=43")
         self.assertEqual(st, 0)
-        st, _ = self.run_command_status("coverage report --fail-under=44")
+        self.assertEqual(self.last_line_squeezed(out), "forty_two_plus.py 7 4 43%")
+
+    def test_report_43_is_not_ok(self):
+        st, out = self.run_command_status("coverage report --fail-under=44")
+        self.assertEqual(st, 2)
+        self.assertEqual(self.last_line_squeezed(out), "forty_two_plus.py 7 4 43%")
+
+    def test_report_42p86_is_not_ok(self):
+        self.make_file(".coveragerc", "[report]\nprecision = 2")
+        st, out = self.run_command_status("coverage report --fail-under=42.88")
         self.assertEqual(st, 2)
+        self.assertEqual(self.last_line_squeezed(out), "forty_two_plus.py 7 4 42.86%")
 
 
 class FailUnderNoFilesTest(CoverageTest):
diff --git a/tests/test_results.py b/tests/test_results.py
index 280694d..deaf811 100644
--- a/tests/test_results.py
+++ b/tests/test_results.py
@@ -78,21 +78,30 @@ class NumbersTest(CoverageTest):
         self.assertEqual(n.ratio_covered, (160, 210))
 
 
-@pytest.mark.parametrize("total, fail_under, result", [
+@pytest.mark.parametrize("total, fail_under, precision, result", [
     # fail_under==0 means anything is fine!
-    (0, 0, False),
-    (0.001, 0, False),
+    (0, 0, 0, False),
+    (0.001, 0, 0, False),
     # very small fail_under is possible to fail.
-    (0.001, 0.01, True),
+    (0.001, 0.01, 0, True),
     # Rounding should work properly.
-    (42.1, 42, False),
-    (42.1, 43, True),
-    (42.857, 42, False),
-    (42.857, 43, False),
-    (42.857, 44, True),
+    (42.1, 42, 0, False),
+    (42.1, 43, 0, True),
+    (42.857, 42, 0, False),
+    (42.857, 43, 0, False),
+    (42.857, 44, 0, True),
+    (42.857, 42.856, 3, False),
+    (42.857, 42.858, 3, True),
+    # If you don't specify precision, your fail-under is rounded.
+    (42.857, 42.856, 0, False),
     # Values near 100 should only be treated as 100 if they are 100.
-    (99.8, 100, True),
-    (100.0, 100, False),
+    (99.8, 100, 0, True),
+    (100.0, 100, 0, False),
+    (99.8, 99.7, 1, False),
+    (99.88, 99.90, 2, True),
+    (99.999, 100, 1, True),
+    (99.999, 100, 2, True),
+    (99.999, 100, 3, True),
 ])
-def test_should_fail_under(total, fail_under, result):
-    assert should_fail_under(total, fail_under) == result
+def test_should_fail_under(total, fail_under, precision, result):
+    assert should_fail_under(float(total), float(fail_under), precision) == result