Support minimal coverage validation in tests

Adds an option (-m, --min_coverage, or {cover_opts, {min_coverage,X}})
to the 'cover' command, where the value is an integer between 0 and 100.

If the total coverage during the analysis is below the value received,
the command will fail with output like:

    ===> Requiring 64% coverage to pass. Only 62% obtained

If the rate is correct, the command silently passes as it currently
does.

This feature allows to enforce code coverage standards in a project if
desired.

src/rebar_prv_cover.erl

@@ -12,6 +12,7 @@
          maybe_write_coverdata/2,
          format_error/1]).
 
+-include_lib("providers/include/providers.hrl").
 -include("rebar.hrl").
 
 -define(PROVIDER, cover).
@@ -62,6 +63,9 @@ maybe_write_coverdata(State, Task) ->
     end.
 
 -spec format_error(any()) -> iolist().
+format_error({min_coverage_failed, {PassRate, Total}}) ->
+    io_lib:format("Requiring ~p% coverage to pass. Only ~p% obtained",
+                  [PassRate, Total]);
 format_error(Reason) ->
     io_lib:format("~p", [Reason]).
 
@@ -102,13 +106,13 @@ do_analyze(State) ->
     %% redirect cover output
     true = redirect_cover_output(State, CoverPid),
     %% analyze!
-    ok = case analyze(State, CoverFiles) of
-        [] -> ok;
+    case analyze(State, CoverFiles) of
+        [] -> {ok, State};
         Analysis ->
             print_analysis(Analysis, verbose(State)),
-            write_index(State, Analysis)
-    end,
-    {ok, State}.
+            write_index(State, Analysis),
+            maybe_fail_coverage(Analysis, State)
+    end.
 
 get_all_coverdata(CoverDir) ->
     ok = filelib:ensure_dir(filename:join([CoverDir, "dummy.log"])),
@@ -213,11 +217,11 @@ format_table(Stats, CoverFiles) ->
     Header = header(MaxLength),
     Separator = separator(MaxLength),
     TotalLabel = format("total", MaxLength),
-    TotalCov = format(calculate_total(Stats), 8),
+    TotalCov = format(calculate_total_string(Stats), 8),
     [io_lib:format("~ts~n~ts~n~ts~n", [Separator, Header, Separator]),
         lists:map(fun({Mod, Coverage, _}) ->
             Name = format(Mod, MaxLength),
-            Cov = format(percentage(Coverage), 8),
+            Cov = format(percentage_string(Coverage), 8),
             io_lib:format("  |  ~ts  |  ~ts  |~n", [Name, Cov])
         end, Stats),
         io_lib:format("~ts~n", [Separator]),
@@ -239,6 +243,9 @@ separator(Width) ->
 
 format(String, Width) -> io_lib:format("~*.ts", [Width, String]).
 
+calculate_total_string(Stats) ->
+    integer_to_list(calculate_total(Stats))++"%".
+
 calculate_total(Stats) ->
     percentage(lists:foldl(
         fun({_Mod, {Cov, Not}, _File}, {CovAcc, NotAcc}) ->
@@ -248,8 +255,10 @@ calculate_total(Stats) ->
         Stats
     )).
 
-percentage({_, 0}) -> "100%";
-percentage({Cov, Not}) -> integer_to_list(trunc((Cov / (Cov + Not)) * 100)) ++ "%".
+percentage_string(Data) -> integer_to_list(percentage(Data))++"%".
+
+percentage({_, 0}) -> 100;
+percentage({Cov, Not}) -> trunc((Cov / (Cov + Not)) * 100).
 
 write_index(State, Coverage) ->
     CoverDir = cover_dir(State),
@@ -279,14 +288,25 @@ write_index_section(F, [{Section, DataFile, Mods}|Rest]) ->
     FmtLink =
         fun({Mod, Cov, Report}) ->
                 ?FMT("<tr><td><a href='~ts'>~ts</a></td><td>~ts</td>\n",
-                     [strip_coverdir(Report), Mod, percentage(Cov)])
+                     [strip_coverdir(Report), Mod, percentage_string(Cov)])
         end,
     lists:foreach(fun(M) -> ok = file:write(F, FmtLink(M)) end, Mods),
     ok = file:write(F, ?FMT("<tr><td><strong>Total</strong></td><td>~ts</td>\n",
-                     [calculate_total(Mods)])),
+                     [calculate_total_string(Mods)])),
     ok = file:write(F, "</table>\n"),
     write_index_section(F, Rest).
 
+maybe_fail_coverage(Analysis, State) ->
+    {_, _CoverFiles, Stats} = lists:keyfind("aggregate", 1, Analysis),
+    Total = calculate_total(Stats),
+    PassRate = min_coverage(State),
+    ?DEBUG("Comparing ~p to pass rate ~p", [Total, PassRate]),
+    if Total >= PassRate ->
+        {ok, State}
+    ;  Total < PassRate ->
+        ?PRV_ERROR({min_coverage_failed, {PassRate, Total}})
+    end.
+
 %% fix for r15b which doesn't put the correct path in the `source` section
 %%  of `module_info(compile)`
 strip_coverdir([]) -> "";
@@ -401,12 +421,23 @@ verbose(State) ->
         {Verbose, _}           -> Verbose
     end.
 
+min_coverage(State) ->
+    Command = proplists:get_value(min_coverage, command_line_opts(State), undefined),
+    Config = proplists:get_value(min_coverage, config_opts(State), undefined),
+    case {Command, Config} of
+        {undefined, undefined} -> 0;
+        {undefined, Rate}   -> Rate;
+        {Rate, _}           -> Rate
+    end.
+
 cover_dir(State) ->
     filename:join([rebar_dir:base_dir(State), "cover"]).
 
 cover_opts(_State) ->
     [{reset, $r, "reset", boolean, help(reset)},
-     {verbose, $v, "verbose", boolean, help(verbose)}].
+     {verbose, $v, "verbose", boolean, help(verbose)},
+     {min_coverage, $m, "min_coverage", integer, help(min_coverage)}].
 
 help(reset) -> "Reset all coverdata.";
-help(verbose) -> "Print coverage analysis.".
+help(verbose) -> "Print coverage analysis.";
+help(min_coverage) -> "Mandate a coverage percentage required to succeed (0..100)".

test/rebar_cover_SUITE.erl

@@ -14,7 +14,9 @@
          flag_verbose/1,
          config_verbose/1,
          excl_mods_and_apps/1,
-         coverdata_is_reset_on_write/1]).
+         coverdata_is_reset_on_write/1,
+         flag_min_coverage/1,
+         config_min_coverage/1]).
 
 -include_lib("common_test/include/ct.hrl").
 -include_lib("eunit/include/eunit.hrl").
@@ -38,7 +40,8 @@ all() ->
      root_extra_src_dirs,
      index_written,
      flag_verbose, config_verbose,
-     excl_mods_and_apps, coverdata_is_reset_on_write].
+     excl_mods_and_apps, coverdata_is_reset_on_write,
+     flag_min_coverage, config_min_coverage].
 
 flag_coverdata_written(Config) ->
     AppDir = ?config(apps, Config),
@@ -257,3 +260,46 @@ coverdata_is_reset_on_write(Config) ->
     Res = lists:map(fun(M) -> cover:analyse(M) end, cover:modules()),
     Ok = lists:foldl(fun({ok, R}, Acc) -> R ++ Acc end, [], Res),
     [] = lists:filter(fun({_, {0,_}}) -> false; (_) -> true end, Ok).
+
+flag_min_coverage(Config) ->
+    AppDir = ?config(apps, Config),
+
+    Name = rebar_test_utils:create_random_name("min_cover_"),
+    Vsn = rebar_test_utils:create_random_vsn(),
+    rebar_test_utils:create_eunit_app(AppDir, Name, Vsn, [kernel, stdlib]),
+
+    RebarConfig = [{erl_opts, [{d, some_define}]}],
+    ?assertMatch({ok, _},
+                 rebar_test_utils:run_and_check(
+                   Config, RebarConfig,
+                   ["do", "eunit", "--cover", ",", "cover", "--min_coverage=5"],
+                   return)),
+
+    ?assertMatch({error,{rebar_prv_cover,{min_coverage_failed,{65,_}}}},
+                 rebar_test_utils:run_and_check(
+                   Config, RebarConfig,
+                   ["do", "eunit", "--cover", ",", "cover", "--min_coverage=65"],
+                   return)),
+    ok.
+
+config_min_coverage(Config) ->
+    AppDir = ?config(apps, Config),
+
+    Name = rebar_test_utils:create_random_name("cover_"),
+    Vsn = rebar_test_utils:create_random_vsn(),
+    rebar_test_utils:create_eunit_app(AppDir, Name, Vsn, [kernel, stdlib]),
+
+    RebarConfig1 = [{erl_opts, [{d, some_define}]}, {cover_opts, [{min_coverage,5}]}],
+    ?assertMatch({ok, _},
+                 rebar_test_utils:run_and_check(
+                   Config, RebarConfig1,
+                   ["do", "eunit", "--cover", ",", "cover"],
+                   return)),
+
+    RebarConfig2 = [{erl_opts, [{d, some_define}]}, {cover_opts, [{min_coverage,65}]}],
+    ?assertMatch({error,{rebar_prv_cover,{min_coverage_failed,{65,_}}}},
+                 rebar_test_utils:run_and_check(
+                   Config, RebarConfig2,
+                   ["do", "eunit", "--cover", ",", "cover"],
+                   return)),
+    ok.