diff options
Diffstat (limited to 'src/rebar_prv_eunit.erl')
-rw-r--r-- | src/rebar_prv_eunit.erl | 528 |
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. |