diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/rebar.app.src | 1 | ||||
| -rw-r--r-- | src/rebar_cover_utils.erl | 261 | ||||
| -rw-r--r-- | src/rebar_erlc_compiler.erl | 4 | ||||
| -rw-r--r-- | src/rebar_prv_eunit.erl | 528 | ||||
| -rw-r--r-- | src/rebar_utils.erl | 18 |
5 files changed, 810 insertions, 2 deletions
diff --git a/src/rebar.app.src b/src/rebar.app.src index 894ca7b..dc3e689 100644 --- a/src/rebar.app.src +++ b/src/rebar.app.src @@ -25,6 +25,7 @@ {providers, [rebar_prv_clean, rebar_prv_deps, rebar_prv_do, + rebar_prv_eunit, rebar_prv_lock, rebar_prv_install_deps, rebar_prv_packages, diff --git a/src/rebar_cover_utils.erl b/src/rebar_cover_utils.erl new file mode 100644 index 0000000..24c769a --- /dev/null +++ b/src/rebar_cover_utils.erl @@ -0,0 +1,261 @@ +%% -*- erlang-indent-level: 4;indent-tabs-mode: nil -*- +%% ex: ts=4 sw=4 et +%% ------------------------------------------------------------------- +%% +%% rebar: Erlang Build Tools +%% +%% Copyright (c) 2009, 2010 Dave Smith (dizzyd@dizzyd.com) +%% Copyright (c) 2013 Andras Horvath (andras.horvath@erlang-solutions.com) +%% +%% Permission is hereby granted, free of charge, to any person obtaining a copy +%% of this software and associated documentation files (the "Software"), to deal +%% in the Software without restriction, including without limitation the rights +%% to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +%% copies of the Software, and to permit persons to whom the Software is +%% furnished to do so, subject to the following conditions: +%% +%% The above copyright notice and this permission notice shall be included in +%% all copies or substantial portions of the Software. +%% +%% THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +%% IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +%% FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +%% AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +%% LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +%% OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +%% THE SOFTWARE. +%% ------------------------------------------------------------------- +-module(rebar_cover_utils). + +%% for internal use only +-export([init/3, + perform_cover/4, + close/1, + exit/0]). + +-include("rebar.hrl"). + +%% ==================================================================== +%% Internal functions +%% ==================================================================== + +perform_cover(Config, BeamFiles, SrcModules, TargetDir) -> + perform_cover(rebar_state:get(Config, cover_enabled, false), + Config, BeamFiles, SrcModules, TargetDir). + +perform_cover(false, _Config, _BeamFiles, _SrcModules, _TargetDir) -> + ok; +perform_cover(true, Config, BeamFiles, SrcModules, TargetDir) -> + analyze(Config, BeamFiles, SrcModules, TargetDir). + +close(not_enabled) -> + ok; +close(F) -> + ok = file:close(F). + +exit() -> + cover:stop(). + +init(false, _BeamFiles, _TargetDir) -> + {ok, not_enabled}; +init(true, BeamFiles, TargetDir) -> + %% Attempt to start the cover server, then set its group leader to + %% TargetDir/cover.log, so all cover log messages will go there instead of + %% to stdout. If the cover server is already started, we'll kill that + %% server and start a new one in order not to inherit a polluted + %% cover_server state. + {ok, CoverPid} = case whereis(cover_server) of + undefined -> + cover:start(); + _ -> + cover:stop(), + cover:start() + end, + + {ok, F} = OkOpen = file:open( + filename:join([TargetDir, "cover.log"]), + [write]), + + group_leader(F, CoverPid), + + ?INFO("Cover compiling ~s\n", [rebar_utils:get_cwd()]), + + Compiled = [{Beam, cover:compile_beam(Beam)} || Beam <- BeamFiles], + case [Module || {_, {ok, Module}} <- Compiled] of + [] -> + %% No modules compiled successfully...fail + ?ERROR("Cover failed to compile any modules; aborting.~n", []), + ?FAIL; + _ -> + %% At least one module compiled successfully + + %% It's not an error for cover compilation to fail partially, + %% but we do want to warn about them + PrintWarning = + fun(Beam, Desc) -> + ?CONSOLE("Cover compilation warning for ~p: ~p", + [Beam, Desc]) + end, + _ = [PrintWarning(Beam, Desc) || {Beam, {error, Desc}} <- Compiled], + OkOpen + end; +init(Config, BeamFiles, TargetDir) -> + init(rebar_state:get(Config, cover_enabled, false), BeamFiles, TargetDir). + +analyze(_Config, [], _SrcModules, _TargetDir) -> + ok; +analyze(Config, FilteredModules, SrcModules, TargetDir) -> + %% Generate coverage info for all the cover-compiled modules + Coverage = lists:flatten([analyze_mod(M) + || M <- FilteredModules, + cover:is_compiled(M) =/= false]), + + %% Write index of coverage info + write_index(lists:sort(Coverage), SrcModules, TargetDir), + + %% Write coverage details for each file + lists:foreach( + fun({M, _, _}) -> + {ok, _} = cover:analyze_to_file(M, + cover_file(M, TargetDir), + [html]) + end, Coverage), + + Index = filename:join([rebar_utils:get_cwd(), TargetDir, "index.html"]), + ?CONSOLE("Cover analysis: ~s\n", [Index]), + + %% Export coverage data, if configured + case rebar_state:get(Config, cover_export_enabled, false) of + true -> + export_coverdata(TargetDir); + false -> + ok + end, + + %% Print coverage report, if configured + case rebar_state:get(Config, cover_print_enabled, false) of + true -> + print_coverage(lists:sort(Coverage)); + false -> + ok + end. + +analyze_mod(Module) -> + case cover:analyze(Module, coverage, module) of + {ok, {Module, {Covered, NotCovered}}} -> + %% Modules that include the eunit header get an implicit + %% test/0 fun, which cover considers a runnable line, but + %% eunit:test(TestRepresentation) never calls. Decrement + %% NotCovered in this case. + [align_notcovered_count(Module, Covered, NotCovered, + is_eunitized(Module))]; + {error, Reason} -> + ?ERROR("Cover analyze failed for ~p: ~p ~p\n", + [Module, Reason, code:which(Module)]), + [] + end. + +is_eunitized(Mod) -> + has_eunit_test_fun(Mod) andalso + has_header(Mod, "include/eunit.hrl"). + +has_eunit_test_fun(Mod) -> + [F || {exports, Funs} <- Mod:module_info(), + {F, 0} <- Funs, F =:= test] =/= []. + +has_header(Mod, Header) -> + Mod1 = case code:which(Mod) of + cover_compiled -> + {file, File} = cover:is_compiled(Mod), + File; + non_existing -> Mod; + preloaded -> Mod; + L -> L + end, + {ok, {_, [{abstract_code, {_, AC}}]}} = + beam_lib:chunks(Mod1, [abstract_code]), + [F || {attribute, 1, file, {F, 1}} <- AC, + string:str(F, Header) =/= 0] =/= []. + +align_notcovered_count(Module, Covered, NotCovered, false) -> + {Module, Covered, NotCovered}; +align_notcovered_count(Module, Covered, NotCovered, true) -> + {Module, Covered, NotCovered - 1}. + +write_index(Coverage, SrcModules, TargetDir) -> + {ok, F} = file:open(filename:join([TargetDir, "index.html"]), [write]), + ok = file:write(F, "<!DOCTYPE HTML><html>\n" + "<head><meta charset=\"utf-8\">" + "<title>Coverage Summary</title></head>\n" + "<body>\n"), + IsSrcCoverage = fun({Mod,_C,_N}) -> lists:member(Mod, SrcModules) end, + {SrcCoverage, TestCoverage} = lists:partition(IsSrcCoverage, Coverage), + write_index_section(F, "Source", SrcCoverage), + write_index_section(F, "Test", TestCoverage), + ok = file:write(F, "</body></html>"), + ok = file:close(F). + +write_index_section(_F, _SectionName, []) -> + ok; +write_index_section(F, SectionName, Coverage) -> + %% Calculate total coverage + {Covered, NotCovered} = lists:foldl(fun({_Mod, C, N}, {CAcc, NAcc}) -> + {CAcc + C, NAcc + N} + end, {0, 0}, Coverage), + TotalCoverage = percentage(Covered, NotCovered), + + %% Write the report + ok = file:write(F, ?FMT("<h1>~s Summary</h1>\n", [SectionName])), + ok = file:write(F, ?FMT("<h3>Total: ~s</h3>\n", [TotalCoverage])), + ok = file:write(F, "<table><tr><th>Module</th><th>Coverage %</th></tr>\n"), + + FmtLink = + fun(Module, Cov, NotCov) -> + ?FMT("<tr><td><a href='~s.COVER.html'>~s</a></td><td>~s</td>\n", + [Module, Module, percentage(Cov, NotCov)]) + end, + lists:foreach(fun({Module, Cov, NotCov}) -> + ok = file:write(F, FmtLink(Module, Cov, NotCov)) + end, Coverage), + ok = file:write(F, "</table>\n"). + +print_coverage(Coverage) -> + {Covered, NotCovered} = lists:foldl(fun({_Mod, C, N}, {CAcc, NAcc}) -> + {CAcc + C, NAcc + N} + end, {0, 0}, Coverage), + TotalCoverage = percentage(Covered, NotCovered), + + %% Determine the longest module name for right-padding + Width = lists:foldl(fun({Mod, _, _}, Acc) -> + case length(atom_to_list(Mod)) of + N when N > Acc -> + N; + _ -> + Acc + end + end, 0, Coverage) * -1, + + %% Print the output the console + ?CONSOLE("~nCode Coverage:~n", []), + lists:foreach(fun({Mod, C, N}) -> + ?CONSOLE("~*s : ~4s~n", + [Width, Mod, percentage(C, N)]) + end, Coverage), + ?CONSOLE("~n~*s : ~s~n", [Width, "Total", TotalCoverage]). + +cover_file(Module, TargetDir) -> + filename:join([TargetDir, atom_to_list(Module) ++ ".COVER.html"]). + +export_coverdata(TargetDir) -> + ExportFile = filename:join(TargetDir, "cover.coverdata"), + case cover:export(ExportFile) of + ok -> + ?CONSOLE("Coverdata export: ~s~n", [ExportFile]); + {error, Reason} -> + ?ERROR("Coverdata export failed: ~p~n", [Reason]) + end. + +percentage(0, 0) -> + "not executed"; +percentage(Cov, NotCov) -> + integer_to_list(trunc((Cov / (Cov + NotCov)) * 100)) ++ "%". diff --git a/src/rebar_erlc_compiler.erl b/src/rebar_erlc_compiler.erl index 33983e4..9a82e3d 100644 --- a/src/rebar_erlc_compiler.erl +++ b/src/rebar_erlc_compiler.erl @@ -142,7 +142,7 @@ clean(Config, AppDir) -> test_compile(Config, Cmd, OutDir) -> %% Obtain all the test modules for inclusion in the compile stage. - TestErls = rebar_utils:find_files("test", ?RE_PREFIX".*\\.erl\$"), + TestErls = rebar_utils:find_files(filename:absname("test"), ?RE_PREFIX".*\\.erl\$"), ErlOpts = rebar_utils:erl_opts(Config), {Config1, ErlOpts1} = test_compile_config_and_opts(Config, ErlOpts, Cmd), @@ -154,7 +154,7 @@ test_compile(Config, Cmd, OutDir) -> SrcErls = lists:foldl( fun(Dir, Acc) -> Files = rebar_utils:find_files( - Dir, ?RE_PREFIX".*\\.erl\$"), + filename:absname(Dir), ?RE_PREFIX".*\\.erl\$"), lists:append(Acc, Files) end, [], SrcDirs), 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. diff --git a/src/rebar_utils.erl b/src/rebar_utils.erl index c39bbfa..6dfbbed 100644 --- a/src/rebar_utils.erl +++ b/src/rebar_utils.erl @@ -39,6 +39,8 @@ find_files/3, ensure_dir/1, beam_to_mod/1, + beam_to_mod/2, + erl_to_mod/1, beams/1, find_executable/1, expand_code_path/0, @@ -356,6 +358,9 @@ expand_sh_flag(return_on_error) -> fun(_Command, Err) -> {error, Err} end}; +expand_sh_flag(abort_on_error) -> + {error_handler, + fun log_and_abort/2}; expand_sh_flag({abort_on_error, Message}) -> {error_handler, log_msg_and_abort(Message)}; @@ -385,6 +390,12 @@ log_msg_and_abort(Message) -> ?ABORT(Message, []) end. +-spec log_and_abort(string(), {integer(), string()}) -> no_return(). +log_and_abort(Command, {Rc, Output}) -> + ?ABORT("sh(~s)~n" + "failed with return code ~w and the following output:~n" + "~s~n", [Command, Rc, Output]). + -spec debug_and_abort(string(), {integer(), string()}) -> no_return(). debug_and_abort(Command, {Rc, Output}) -> ?DEBUG("sh(~s)~n" @@ -404,9 +415,16 @@ sh_loop(Port, Fun, Acc) -> {error, {Rc, lists:flatten(lists:reverse(Acc))}} end. +beam_to_mod(Dir, Filename) -> + [Dir | Rest] = filename:split(Filename), + list_to_atom(filename:basename(string:join(Rest, "."), ".beam")). + beam_to_mod(Filename) -> list_to_atom(filename:basename(Filename, ".beam")). +erl_to_mod(Filename) -> + list_to_atom(filename:rootname(filename:basename(Filename))). + beams(Dir) -> filelib:fold_files(Dir, ".*\.beam\$", true, fun(F, Acc) -> [F | Acc] end, []). |