add eunit task, still work to be done

1 files changed, 528 insertions, 0 deletions

diff --git a/src/rebar_prv_eunit.erl b/src/rebar_prv_eunit.erl
new file mode 100644
index 0000000..1607d08
--- /dev/null
+++ b/src/rebar_prv_eunit.erl
@@ -0,0 +1,528 @@
+%% -*- erlang-indent-level: 4;indent-tabs-mode: nil -*-
+%% ex: ts=4 sw=4 et
+
+-module(rebar_prv_eunit).
+
+-behaviour(provider).
+
+-export([init/1,
+         do/1,
+         format_error/2]).
+
+-include("rebar.hrl").
+
+-define(PROVIDER, eunit).
+
+-define(DEPS, [compile]).
+-define(EUNIT_DIR, ".eunit").
+
+%% ===================================================================
+%% Public API
+%% ===================================================================
+
+-spec init(rebar_state:t()) -> {ok, rebar_state:t()}.
+init(State) ->
+    State1 = rebar_state:add_provider(State, providers:create([{name, ?PROVIDER},
+                                                               {module, ?MODULE},
+                                                               {bare, false},
+                                                               {deps, ?DEPS},
+                                                               {example, "rebar eunit"},
+                                                               {short_desc, "Run eunit tests on project apps."},
+                                                               {desc, ""},
+                                                               {opts, []}])),
+
+    {ok, State1}.
+
+-spec do(rebar_state:t()) -> {ok, rebar_state:t()} | {error, string()}.
+do(State) ->
+    ok = ensure_dirs(),
+    %% Save code path
+    CodePath = setup_code_path(),
+    CompileOnly = rebar_state:get(State, compile_only, false),
+    {ok, SrcErls} = rebar_erlc_compiler:test_compile(State, "eunit",
+                                                     ?EUNIT_DIR),
+    case CompileOnly of
+        "true" ->
+            true = rebar_utils:cleanup_code_path(CodePath),
+            ?CONSOLE("Compiled modules for eunit~n", []);
+        false ->
+            run_eunit(State, CodePath, SrcErls)
+    end,
+    {ok, State}.
+
+-spec format_error(any(), rebar_state:t()) ->  {iolist(), rebar_state:t()}.
+format_error(Reason, State) ->
+    {io_lib:format("~p", [Reason]), State}.
+
+run_eunit(Config, CodePath, SrcErls) ->
+    %% Build a list of all the .beams in ?EUNIT_DIR -- use this for
+    %% 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.
+    AllBeamFiles = rebar_utils:beams(?EUNIT_DIR),
+    {BeamFiles, TestBeamFiles} =
+        lists:partition(fun(N) -> string:str(N, "_tests.beam") =:= 0 end,
+                        AllBeamFiles),
+    OtherBeamFiles = TestBeamFiles --
+        [filename:rootname(N) ++ "_tests.beam" || N <- AllBeamFiles],
+    ModuleBeamFiles = randomize_suites(Config, BeamFiles ++ OtherBeamFiles),
+    %% Get matching tests and modules
+    AllModules = [rebar_utils:beam_to_mod(?EUNIT_DIR, N) || N <- AllBeamFiles],
+    {Tests, FilteredModules} =
+        get_tests_and_modules(Config, ModuleBeamFiles, AllModules),
+    SrcModules = [rebar_utils:erl_to_mod(M) || M <- SrcErls],
+    {ok, CoverLog} = rebar_cover_utils:init(Config, ModuleBeamFiles,
+                                            eunit_dir()),
+    StatusBefore = status_before_eunit(),
+    EunitResult = perform_eunit(Config, Tests),
+    rebar_cover_utils:perform_cover(Config, FilteredModules, SrcModules,
+                                    eunit_dir()),
+    rebar_cover_utils:close(CoverLog),
+    case proplists:get_value(reset_after_eunit, get_eunit_opts(Config),
+                             true) of
+        true ->
+            reset_after_eunit(StatusBefore);
+        false ->
+            ok
+    end,
+    %% Stop cover to clean the cover_server state. This is important if we want
+    %% eunit+cover to not slow down when analyzing many Erlang modules.
+    ok = rebar_cover_utils:exit(),
+    case EunitResult of
+        ok ->
+            ok;
+        _ ->
+            ?ABORT("One or more eunit tests failed.~n", [])
+    end,
+    %% Restore code path
+    true = rebar_utils:cleanup_code_path(CodePath),
+    ok.
+ensure_dirs() ->
+    %% Make sure ?EUNIT_DIR/ and ebin/ directory exists (append dummy module)
+    ok = filelib:ensure_dir(filename:join(eunit_dir(), "dummy")),
+    ok = filelib:ensure_dir(filename:join(rebar_utils:ebin_dir(), "dummy")).
+eunit_dir() ->
+    filename:join(rebar_utils:get_cwd(), ?EUNIT_DIR).
+setup_code_path() ->
+    %% Setup code path prior to compilation so that parse_transforms
+    %% and the like work properly. Also, be sure to add ebin_dir()
+    %% to the END of the code path so that we don't have to jump
+    %% through hoops to access the .app file
+    CodePath = code:get_path(),
+    true = code:add_patha(eunit_dir()),
+    true = code:add_pathz(rebar_utils:ebin_dir()),
+    CodePath.
+%%
+%% == get matching tests ==
+%%
+get_tests_and_modules(Config, ModuleBeamFiles, AllModules) ->
+    SelectedSuites = get_selected_suites(Config, AllModules),
+    {Tests, QualifiedTests} = get_qualified_and_unqualified_tests(Config),
+    Modules = get_test_modules(SelectedSuites, Tests,
+                               QualifiedTests, ModuleBeamFiles),
+    FilteredModules = get_matching_modules(AllModules, Modules, QualifiedTests),
+    MatchedTests = get_matching_tests(Modules, Tests, QualifiedTests),
+    {MatchedTests, FilteredModules}.
+%%
+%% == get suites specified via 'suites' option ==
+%%
+get_selected_suites(Config, Modules) ->
+    RawSuites = get_suites(Config),
+    Suites = [list_to_atom(Suite) || Suite <- string:tokens(RawSuites, ",")],
+    [M || M <- Suites, lists:member(M, Modules)].
+get_suites(Config) ->
+    case rebar_state:get(Config, suites, "") of
+        "" ->
+            rebar_state:get(Config, suite, "");
+        Suites ->
+            Suites
+    end.
+get_qualified_and_unqualified_tests(Config) ->
+    RawFunctions = rebar_state:get(Config, tests, ""),
+    FunctionNames = [FunctionName ||
+                        FunctionName <- string:tokens(RawFunctions, ",")],
+    get_qualified_and_unqualified_tests1(FunctionNames, [], []).
+get_qualified_and_unqualified_tests1([], Functions, QualifiedFunctions) ->
+    {Functions, QualifiedFunctions};
+get_qualified_and_unqualified_tests1([TestName|TestNames], Functions,
+                                     QualifiedFunctions) ->
+    case string:tokens(TestName, ":") of
+        [TestName] ->
+            Function = list_to_atom(TestName),
+            get_qualified_and_unqualified_tests1(
+              TestNames, [Function|Functions], QualifiedFunctions);
+        [ModuleName, FunctionName] ->
+            M = list_to_atom(ModuleName),
+            F = list_to_atom(FunctionName),
+            get_qualified_and_unqualified_tests1(TestNames, Functions,
+                                                 [{M, F}|QualifiedFunctions]);
+        _ ->
+            ?ABORT("Unsupported test function specification: ~s~n", [TestName])
+    end.
+%% Provide modules which are to be searched for tests.
+%% Several scenarios are possible:
+%%
+%% == randomize suites ==
+%%
+randomize_suites(Config, Modules) ->
+    case rebar_state:get(Config, random_suite_order, undefined) of
+        undefined ->
+            Modules;
+        "true" ->
+            Seed = crypto:rand_uniform(1, 65535),
+            randomize_suites1(Modules, Seed);
+        String ->
+            try list_to_integer(String) of
+                Seed ->
+                    randomize_suites1(Modules, Seed)
+            catch
+                error:badarg ->
+                    ?ERROR("Bad random seed provided: ~p~n", [String]),
+                    ?FAIL
+            end
+    end.
+randomize_suites1(Modules, Seed) ->
+    _ = random:seed(35, Seed, 1337),
+    ?CONSOLE("Randomizing suite order with seed ~b~n", [Seed]),
+    [X||{_,X} <- lists:sort([{random:uniform(), M} || M <- Modules])].
+%%
+%% == get matching tests ==
+%% 1) Specific tests have been provided and/or
+%% no unqualified tests have been specified and
+%% there were some qualified tests, then we can search for
+%% functions in specified suites (or in empty set of suites).
+%%
+%% 2) Neither specific suites nor qualified test names 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)."
+get_test_modules(SelectedSuites, Tests, QualifiedTests, ModuleBeamFiles) ->
+    SuitesProvided = SelectedSuites =/= [],
+    OnlyQualifiedTestsProvided = QualifiedTests =/= [] andalso Tests =:= [],
+    if
+        SuitesProvided orelse OnlyQualifiedTestsProvided ->
+            SelectedSuites;
+        true ->
+            [rebar_utils:beam_to_mod(?EUNIT_DIR, N) ||
+                N <- ModuleBeamFiles]
+    end.
+get_matching_modules(AllModules, Modules, QualifiedTests) ->
+    ModuleFilterMapper =
+        fun({M, _}) ->
+                case lists:member(M, AllModules) of
+                    true -> {true, M};
+                    _-> false
+                end
+        end,
+    ModulesFromQualifiedTests = lists:zf(ModuleFilterMapper, QualifiedTests),
+    lists:usort(Modules ++ ModulesFromQualifiedTests).
+get_matching_tests(Modules, [], []) ->
+    Modules;
+get_matching_tests(Modules, [], QualifiedTests) ->
+    FilteredQualifiedTests = filter_qualified_tests(Modules, QualifiedTests),
+    lists:merge(Modules, make_test_primitives(FilteredQualifiedTests));
+get_matching_tests(Modules, Tests, QualifiedTests) ->
+    AllTests = lists:merge(QualifiedTests,
+                           get_matching_tests1(Modules, Tests, [])),
+    make_test_primitives(AllTests).
+filter_qualified_tests(Modules, QualifiedTests) ->
+    TestsFilter = fun({Module, _Function}) ->
+                          lists:all(fun(M) -> M =/= Module end, Modules) end,
+    lists:filter(TestsFilter, QualifiedTests).
+get_matching_tests1([], _Functions, TestFunctions) ->
+    TestFunctions;
+get_matching_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 = get_matching_tests2(Functions, {Module, ModuleExports},
+                                {list_to_atom(TestModuleStr),
+                                 TestModuleExports}),
+    get_matching_tests1(TModules, Functions,
+                        lists:merge([TestFunctions, Tests])).
+get_matching_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.
+make_test_primitives(RawTests) ->
+    %% Use {test,M,F} and {generator,M,F} if at least R15B02. Otherwise,
+    %% use eunit_test:function_wrapper/2 fallback.
+    %% eunit_test:function_wrapper/2 was renamed to eunit_test:mf_wrapper/2
+    %% in R15B02; use that as >= R15B02 check.
+    %% TODO: remove fallback and use only {test,M,F} and {generator,M,F}
+    %% primitives once at least R15B02 is required.
+    {module, eunit_test} = code:ensure_loaded(eunit_test),
+    MakePrimitive = case erlang:function_exported(eunit_test, mf_wrapper, 2) of
+                        true -> fun eunit_primitive/3;
+                        false -> fun pre15b02_eunit_primitive/3
+                    end,
+    ?CONSOLE(" Running test function(s):~n", []),
+    F = fun({M, F2}, Acc) ->
+                ?CONSOLE(" ~p:~p/0~n", [M, F2]),
+                FNameStr = atom_to_list(F2),
+                NewFunction =
+                    case re:run(FNameStr, "_test_") of
+                        nomatch ->
+                            %% Normal test
+                            MakePrimitive(test, M, F2);
+                        _ ->
+                            %% Generator
+                            MakePrimitive(generator, M, F2)
+                    end,
+                [NewFunction|Acc]
+        end,
+    lists:foldl(F, [], RawTests).
+eunit_primitive(Type, M, F) ->
+    {Type, M, F}.
+pre15b02_eunit_primitive(test, M, F) ->
+    eunit_test:function_wrapper(M, F);
+pre15b02_eunit_primitive(generator, M, F) ->
+    {generator, eunit_test:function_wrapper(M, F)}.
+%%
+%% == run tests ==
+%%
+perform_eunit(Config, Tests) ->
+    EunitOpts = get_eunit_opts(Config),
+    %% Move down into ?EUNIT_DIR while we run tests so any generated files
+    %% are created there (versus in the source dir)
+    Cwd = rebar_utils:get_cwd(),
+    ok = file:set_cwd(?EUNIT_DIR),
+    EunitResult = (catch eunit:test(Tests, EunitOpts)),
+    %% Return to original working dir
+    ok = file:set_cwd(Cwd),
+    EunitResult.
+get_eunit_opts(Config) ->
+    %% Enable verbose in eunit if so requested..
+    BaseOpts = case rebar_log:is_verbose(Config) of
+                   true ->
+                       [verbose];
+                   false ->
+                       []
+               end,
+    BaseOpts ++ rebar_state:get(Config, eunit_opts, []).
+%%
+%% == reset_after_eunit ==
+%%
+status_before_eunit() ->
+    Apps = get_app_names(),
+    AppEnvs = [{App, application:get_all_env(App)} || App <- Apps],
+    {erlang:processes(), erlang:is_alive(), AppEnvs, ets:tab2list(ac_tab)}.
+get_app_names() ->
+    [AppName || {AppName, _, _} <- application:loaded_applications()].
+reset_after_eunit({OldProcesses, WasAlive, OldAppEnvs, _OldACs}) ->
+    IsAlive = erlang:is_alive(),
+    if not WasAlive andalso IsAlive ->
+            ?DEBUG("Stopping net kernel....\n", []),
+            erl_epmd:stop(),
+            _ = net_kernel:stop(),
+            pause_until_net_kernel_stopped();
+       true ->
+            ok
+    end,
+    OldApps = [App || {App, _} <- OldAppEnvs],
+    Apps = get_app_names(),
+    _ = [begin
+             _ = case lists:member(App, OldApps) of
+                     true -> ok;
+                     false -> application:stop(App)
+                 end,
+             ok = application:unset_env(App, K)
+         end || App <- Apps, App /= rebar,
+                {K, _V} <- application:get_all_env(App),
+                K =/= included_applications],
+    reconstruct_app_env_vars(Apps),
+    Processes = erlang:processes(),
+    _ = kill_extras(Processes -- OldProcesses),
+    ok.
+kill_extras(Pids) ->
+    %% Killing any of the procs below will either:
+    %% 1. Interfere with stuff that we don't want interfered with, or
+    %% 2. May/will force the 'kernel' app to shutdown, which *will*
+    %% interfere with rebar's ability To Do Useful Stuff(tm).
+    %% This list may require changes as OTP versions and/or
+    %% rebar use cases change.
+    KeepProcs = [cover_server, eunit_server,
+                 eqc, eqc_license, eqc_locked,
+                 %% inet_gethost_native is started on demand, when
+                 %% doing name lookups. It is under kernel_sup, under
+                 %% a supervisor_bridge.
+                 inet_gethost_native],
+    Killed = [begin
+                  Info = case erlang:process_info(Pid) of
+                             undefined -> [];
+                             Else -> Else
+                         end,
+                  Keep1 = case proplists:get_value(registered_name, Info) of
+                              undefined ->
+                                  false;
+                              Name ->
+                                  lists:member(Name, KeepProcs)
+                          end,
+                  Keep2 = case proplists:get_value(dictionary, Info) of
+                              undefined ->
+                                  false;
+                              Ds ->
+                                  case proplists:get_value('$ancestors', Ds) of
+                                      undefined ->
+                                          false;
+                                      As ->
+                                          lists:member(kernel_sup, As)
+                                  end
+                          end,
+                  if Keep1 orelse Keep2 ->
+                          ok;
+                     true ->
+                          ?DEBUG("Kill ~p ~p\n", [Pid, Info]),
+                          exit(Pid, kill),
+                          Pid
+                  end
+              end || Pid <- Pids],
+    case lists:usort(Killed) -- [ok] of
+        [] ->
+            ?DEBUG("No processes to kill\n", []),
+            [];
+        Else ->
+            lists:foreach(fun(Pid) -> wait_until_dead(Pid) end, Else),
+            Else
+    end.
+reconstruct_app_env_vars([App|Apps]) ->
+    CmdLine0 = proplists:get_value(App, init:get_arguments(), []),
+    CmdVars = [{list_to_atom(K), list_to_atom(V)} || {K, V} <- CmdLine0],
+    AppFile = (catch filename:join([code:lib_dir(App),
+                                    "ebin",
+                                    atom_to_list(App) ++ ".app"])),
+    AppVars = case file:consult(AppFile) of
+                  {ok, [{application, App, Ps}]} ->
+                      proplists:get_value(env, Ps, []);
+                  _ ->
+                      []
+              end,
+    %% App vars specified in config files override those in the .app file.
+    %% Config files later in the args list override earlier ones.
+    AppVars1 = case init:get_argument(config) of
+                   {ok, ConfigFiles} ->
+                       {App, MergedAppVars} = lists:foldl(fun merge_app_vars/2,
+                                                          {App, AppVars},
+                                                          ConfigFiles),
+                       MergedAppVars;
+                   error ->
+                       AppVars
+               end,
+    AllVars = CmdVars ++ AppVars1,
+    ?DEBUG("Reconstruct ~p ~p\n", [App, AllVars]),
+    lists:foreach(fun({K, V}) -> application:set_env(App, K, V) end, AllVars),
+    reconstruct_app_env_vars(Apps);
+reconstruct_app_env_vars([]) ->
+    ok.
+merge_app_vars(ConfigFile, {App, AppVars}) ->
+    File = ensure_config_extension(ConfigFile),
+    FileAppVars = app_vars_from_config_file(File, App),
+    Dict1 = dict:from_list(AppVars),
+    Dict2 = dict:from_list(FileAppVars),
+    Dict3 = dict:merge(fun(_Key, _Value1, Value2) -> Value2 end, Dict1, Dict2),
+    {App, dict:to_list(Dict3)}.
+ensure_config_extension(File) ->
+    %% config files must end with .config on disk but when specifying them
+    %% via the -config option the extension is optional
+    BaseFileName = filename:basename(File, ".config"),
+    DirName = filename:dirname(File),
+    filename:join(DirName, BaseFileName ++ ".config").
+app_vars_from_config_file(File, App) ->
+    case file:consult(File) of
+        {ok, [Env]} ->
+            proplists:get_value(App, Env, []);
+        _ ->
+            []
+    end.
+wait_until_dead(Pid) when is_pid(Pid) ->
+    Ref = erlang:monitor(process, Pid),
+    receive
+        {'DOWN', Ref, process, _Obj, Info} ->
+            Info
+    after 10*1000 ->
+            exit({timeout_waiting_for, Pid})
+    end;
+wait_until_dead(_) ->
+    ok.
+pause_until_net_kernel_stopped() ->
+    pause_until_net_kernel_stopped(10).
+pause_until_net_kernel_stopped(0) ->
+    exit(net_kernel_stop_failed);
+pause_until_net_kernel_stopped(N) ->
+    case node() of
+        'nonode@nohost' ->
+            ?DEBUG("Stopped net kernel.\n", []),
+            ok;
+        _ ->
+            timer:sleep(100),
+            pause_until_net_kernel_stopped(N - 1)
+    end.