Add experimental tests= filter for eunit suites

2 files changed, 145 insertions, 27 deletions

diff --git a/src/rebar.erl b/src/rebar.erl
index 44ba00b..aec516b 100644
--- a/src/rebar.erl
+++ b/src/rebar.erl
@@ -297,7 +297,9 @@ generate-upgrade  previous_release=path  Build an upgrade package
 
 generate-appups   previous_release=path  Generate appup files
 
-eunit       [suites=foo]             Run eunit [test/foo_tests.erl] tests
+eunit       [suites=foo]             Run eunit tests [foo.erl and test/foo_tests.erl]
+            [suites=foo] [tests=bar] Run specific eunit tests [first test name starting
+                                     with 'bar' in foo.erl and test/foo_tests.erl]
 ct          [suites=] [case=]        Run common_test suites
 
 qc                                   Test QuickCheck properties
diff --git a/src/rebar_eunit.erl b/src/rebar_eunit.erl
index 85eca3a..8e09452 100644
--- a/src/rebar_eunit.erl
+++ b/src/rebar_eunit.erl
@@ -43,7 +43,14 @@
 %% The following Global options are supported:
 %% <ul>
 %%   <li>verbose=1 - show extra output from the eunit test</li>
-%%   <li>suites="foo,bar" - runs test/foo_tests.erl and test/bar_tests.erl</li>
+%%   <li>
+%%      suites="foo,bar" - runs tests in foo.erl, test/foo_tests.erl and
+%%      tests in bar.erl, test/bar_tests.erl
+%%   </li>
+%%   <li>
+%%      suites="foo,bar" tests="baz"- runs first test with name starting
+%%      with 'baz' in foo.erl, test/foo_tests.erl and tests in bar.erl,
+%%      test/bar_tests.erl
 %% </ul>
 %% Additionally, for projects that have separate folders for the core
 %% implementation, and for the unit tests, then the following
@@ -92,21 +99,7 @@ run_eunit(Config, CodePath, SrcErls) ->
     %% cover and eunit testing. Normally you can just tell cover
     %% and/or eunit to scan the directory for you, but eunit does a
     %% code:purge in conjunction with that scan and causes any cover
-    %% compilation info to be lost.  Filter out "*_tests" modules so
-    %% eunit won't doubly run them and so cover only calculates
-    %% coverage on production code.  However, keep "*_tests" modules
-    %% that are not automatically included by eunit.
-    %%
-    %% From 'Primitives' in the EUnit User's Guide
-    %% http://www.erlang.org/doc/apps/eunit/chapter.html
-    %% "In addition, EUnit will also look for another module whose
-    %% name is ModuleName plus the suffix _tests, and if it exists,
-    %% all the tests from that module will also be added. (If
-    %% ModuleName already contains the suffix _tests, this is not
-    %% done.) E.g., the specification {module, mymodule} will run all
-    %% tests in the modules mymodule and mymodule_tests. Typically,
-    %% the _tests module should only contain test cases that use the
-    %% public interface of the main module (and no other code)."
+    %% compilation info to be lost.
 
     AllBeamFiles = rebar_utils:beams(?EUNIT_DIR),
     {BeamFiles, TestBeamFiles} =
@@ -115,16 +108,20 @@ run_eunit(Config, CodePath, SrcErls) ->
     OtherBeamFiles = TestBeamFiles --
         [filename:rootname(N) ++ "_tests.beam" || N <- AllBeamFiles],
     ModuleBeamFiles = BeamFiles ++ OtherBeamFiles,
-    Modules = [rebar_utils:beam_to_mod(?EUNIT_DIR, N) || N <- ModuleBeamFiles],
+
+    %% Get modules to be run in eunit
+    AllModules = [rebar_utils:beam_to_mod(?EUNIT_DIR, N) || N <- AllBeamFiles],
+    {SuitesProvided, FilteredModules} = filter_suites(Config, AllModules),
+    Tests = get_tests(Config, SuitesProvided, ModuleBeamFiles, FilteredModules),
+
     SrcModules = [rebar_utils:erl_to_mod(M) || M <- SrcErls],
-    FilteredModules = filter_modules(Config, Modules),
 
     {ok, CoverLog} = cover_init(Config, ModuleBeamFiles),
 
     StatusBefore = status_before_eunit(),
-    EunitResult = perform_eunit(Config, FilteredModules),
-    perform_cover(Config, FilteredModules, SrcModules),
+    EunitResult = perform_eunit(Config, Tests),
 
+    perform_cover(Config, FilteredModules, SrcModules),
     cover_close(CoverLog),
 
     case proplists:get_value(reset_after_eunit, get_eunit_opts(Config),
@@ -164,17 +161,136 @@ setup_code_path() ->
     true = code:add_pathz(rebar_utils:ebin_dir()),
     CodePath.
 
-filter_modules(Config, Modules) ->
+filter_suites(Config, Modules) ->
     RawSuites = rebar_config:get_global(Config, suites, ""),
+    SuitesProvided = RawSuites =/= "",
     Suites = [list_to_atom(Suite) || Suite <- string:tokens(RawSuites, ",")],
-    filter_modules1(Modules, Suites).
+    {SuitesProvided, filter_suites1(Modules, Suites)}.
 
-filter_modules1(Modules, []) ->
+filter_suites1(Modules, []) ->
     Modules;
-filter_modules1(Modules, Suites) ->
+filter_suites1(Modules, Suites) ->
     [M || M <- Modules, lists:member(M, Suites)].
 
-perform_eunit(Config, FilteredModules) ->
+get_tests(Config, SuitesProvided, ModuleBeamFiles, FilteredModules) ->
+    case SuitesProvided of
+        false ->
+            %% No specific suites have been provided, use ModuleBeamFiles
+            %% which filters out "*_tests" modules so eunit won't doubly run
+            %% them and cover only calculates coverage on production code.
+            %% However, keep "*_tests" modules that are not automatically
+            %% included by eunit.
+            %%
+            %% From 'Primitives' in the EUnit User's Guide
+            %% http://www.erlang.org/doc/apps/eunit/chapter.html
+            %% "In addition, EUnit will also look for another module whose
+            %% name is ModuleName plus the suffix _tests, and if it exists,
+            %% all the tests from that module will also be added. (If
+            %% ModuleName already contains the suffix _tests, this is not
+            %% done.) E.g., the specification {module, mymodule} will run all
+            %% tests in the modules mymodule and mymodule_tests. Typically,
+            %% the _tests module should only contain test cases that use the
+            %% public interface of the main module (and no other code)."
+            [rebar_utils:beam_to_mod(?EUNIT_DIR, N) || N <- ModuleBeamFiles];
+        true ->
+            %% Specific suites have been provided, return the existing modules
+            build_tests(Config, FilteredModules)
+    end.
+
+build_tests(Config, SuitesModules) ->
+    RawFunctions = rebar_utils:get_experimental_global(Config, tests, ""),
+    Tests = [list_to_atom(F1) || F1 <- string:tokens(RawFunctions, ",")],
+    case Tests of
+        [] ->
+            SuitesModules;
+        Functions ->
+            case build_tests1(SuitesModules, Functions, []) of
+                [] ->
+                    [];
+                RawTests ->
+                    ?CONSOLE("    Running test function(s):~n", []),
+                    F = fun({M, F2}, Acc) ->
+                                ?CONSOLE("      ~p:~p/0~n", [M, F2]),
+                                [eunit_test:function_wrapper(M, F2)|Acc]
+                        end,
+                    lists:foldl(F, [], RawTests)
+            end
+    end.
+
+build_tests1([], _Functions, TestFunctions) ->
+    TestFunctions;
+
+build_tests1([Module|TModules], Functions, TestFunctions) ->
+    %% Get module exports
+    ModuleStr = atom_to_list(Module),
+    ModuleExports = get_beam_test_exports(ModuleStr),
+    %% Get module _tests exports
+    TestModuleStr = string:concat(ModuleStr, "_tests"),
+    TestModuleExports = get_beam_test_exports(TestModuleStr),
+    %% Build tests {M, F} list
+    Tests = build_tests2(Functions, {Module, ModuleExports},
+                         {list_to_atom(TestModuleStr), TestModuleExports}),
+    build_tests1(TModules, Functions, lists:merge([TestFunctions, Tests])).
+
+build_tests2(Functions, {Mod, ModExports}, {TestMod, TestModExports}) ->
+    %% Look for matching functions into ModExports
+    ModExportsStr = [atom_to_list(E1) || E1 <- ModExports],
+    TestModExportsStr = [atom_to_list(E2) || E2 <- TestModExports],
+    get_matching_exports(Functions, {Mod, ModExportsStr},
+                         {TestMod, TestModExportsStr}, []).
+
+get_matching_exports([], _, _, Matched) ->
+    Matched;
+get_matching_exports([Function|TFunctions], {Mod, ModExportsStr},
+                     {TestMod, TestModExportsStr}, Matched) ->
+
+    FunctionStr = atom_to_list(Function),
+    %% Get matching Function in module, otherwise look in _tests module
+    NewMatch = case get_matching_export(FunctionStr, ModExportsStr) of
+                   [] ->
+                       {TestMod, get_matching_export(FunctionStr,
+                                                     TestModExportsStr)};
+                   MatchingExport ->
+                       {Mod, MatchingExport}
+               end,
+    case NewMatch of
+        {_, []} ->
+            get_matching_exports(TFunctions, {Mod, ModExportsStr},
+                                 {TestMod, TestModExportsStr}, Matched);
+        _ ->
+            get_matching_exports(TFunctions, {Mod, ModExportsStr},
+                                 {TestMod, TestModExportsStr},
+                                 [NewMatch|Matched])
+    end.
+
+get_matching_export(_FunctionStr, []) ->
+    [];
+get_matching_export(FunctionStr, [ExportStr|TExportsStr]) ->
+    case string:str(ExportStr, FunctionStr) of
+        1 ->
+            list_to_atom(ExportStr);
+        _ ->
+            get_matching_export(FunctionStr, TExportsStr)
+    end.
+
+get_beam_test_exports(ModuleStr) ->
+    FilePath = filename:join(eunit_dir(),
+                             string:concat(ModuleStr, ".beam")),
+    case filelib:is_regular(FilePath) of
+        true ->
+            {beam_file, _, Exports0, _, _, _} = beam_disasm:file(FilePath),
+            Exports1 = [FunName || {FunName, FunArity, _} <- Exports0,
+                                   FunArity =:= 0],
+            F = fun(FName) ->
+                        FNameStr = atom_to_list(FName),
+                        re:run(FNameStr, "_test(_)?") =/= nomatch
+                end,
+            lists:filter(F, Exports1);
+        _ ->
+            []
+    end.
+
+perform_eunit(Config, Tests) ->
     EunitOpts = get_eunit_opts(Config),
 
     %% Move down into ?EUNIT_DIR while we run tests so any generated files
@@ -182,7 +298,7 @@ perform_eunit(Config, FilteredModules) ->
     Cwd = rebar_utils:get_cwd(),
     ok = file:set_cwd(?EUNIT_DIR),
 
-    EunitResult = (catch eunit:test(FilteredModules, EunitOpts)),
+    EunitResult = (catch eunit:test(Tests, EunitOpts)),
 
     %% Return to original working dir
     ok = file:set_cwd(Cwd),