From eb34901ab7bd655dce3a83b8f29bc8a5211f5080 Mon Sep 17 00:00:00 2001 From: alisdair sullivan Date: Thu, 1 Jan 2015 16:39:46 -0800 Subject: reworked eunit provider compiles apps and eunit test files in a temporary dir (or a user specified dir) and runs tests without leaving artifacts in the source tree automatically defines the 'TEST' macro if not already defined and adds `test` to `src_dirs` to allow for eunit test files outside `src` --- src/rebar_prv_eunit.erl | 603 +++++++++--------------------------------------- 1 file changed, 110 insertions(+), 493 deletions(-) (limited to 'src') diff --git a/src/rebar_prv_eunit.erl b/src/rebar_prv_eunit.erl index c14a15d..cb0e850 100644 --- a/src/rebar_prv_eunit.erl +++ b/src/rebar_prv_eunit.erl @@ -12,9 +12,7 @@ -include("rebar.hrl"). -define(PROVIDER, eunit). - -define(DEPS, [compile]). --define(EUNIT_DIR, ".eunit"). %% =================================================================== %% Public API @@ -22,507 +20,126 @@ -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, []}])), - + Provider = providers:create([{name, ?PROVIDER}, + {module, ?MODULE}, + {deps, ?DEPS}, + {bare, false}, + {example, "rebar eunit"}, + {short_desc, "Run EUnit Tests."}, + {desc, ""}, + {opts, eunit_opts(State)}, + {profile, test}]), + State1 = rebar_state:add_provider(State, Provider), {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) + ?INFO("Performing EUnit tests...", []), + {RawOpts, _} = rebar_state:command_parsed_args(State), + Opts = transform_opts(RawOpts, State), + ProjectApps = rebar_state:project_apps(State), + OutDir = case proplists:get_value(outdir, Opts, undefined) of + undefined -> filename:join([rebar_state:dir(State), + ec_file:insecure_mkdtemp()]); + Path -> Path end, - {ok, State}. + ?DEBUG("Compiling EUnit instrumented modules in: ~p", [OutDir]), + lists:foreach(fun(App) -> + AppDir = rebar_app_info:dir(App), + C = rebar_config:consult(AppDir), + S = rebar_state:new(State, C, AppDir), + %% combine `erl_first_files` and `eunit_first_files` and adjust + %% compile opts to include `eunit_compile_opts`, `{d, 'TEST'}` + %% and `{src_dirs, "test"}` + TestState = first_files(test_opts(S, OutDir)), + ok = rebar_erlc_compiler:compile(TestState, AppDir) + end, ProjectApps), + true = code:add_patha(OutDir), + EUnitOpts = resolve_eunit_opts(State, Opts), + AppsToTest = [{application, erlang:binary_to_atom(rebar_app_info:name(App), unicode)} + || App <- ProjectApps], + case handle_results(eunit:test(AppsToTest, EUnitOpts)) of + {error, Reason} -> + {error, {?MODULE, Reason}}; + ok -> + {ok, State} + end. -spec format_error(any()) -> iolist(). -format_error(Reason) -> - io_lib:format("~p", [Reason]). +format_error(unknown_error) -> + io_lib:format("Error running tests", []); +format_error({error_running_tests, Reason}) -> + io_lib:format("Error running tests: ~p", [Reason]). -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.", []) +eunit_opts(_State) -> + [{outdir, $o, "outdir", string, help(outdir)}, + {verbose, $v, "verbose", boolean, help(verbose)}]. + +help(outdir) -> "Output directory for EUnit compiled modules"; +help(verbose) -> "Verbose output". + +transform_opts(Opts, State) -> transform_opts(Opts, State, []). + +transform_opts([], _State, Acc) -> Acc; +transform_opts([{outdir, Path}|Rest], State, Acc) -> + NewAcc = case filename:pathtype(Path) of + absolute -> [{outdir, Path}] ++ Acc; + _ -> [{outdir, filename:join([rebar_state:dir(State), Path])}] ++ Acc 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_dir:ebin_dir(), "dummy")). -eunit_dir() -> - filename:join(rebar_dir: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_dir: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", [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", [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); - _ -> - [] + transform_opts(Rest, State, NewAcc); +transform_opts([{Key, Val}|Rest], State, Acc) -> + transform_opts(Rest, State, [{Key, Val}|Acc]). + +test_opts(State, TmpDir) -> + ErlOpts = rebar_state:get(State, eunit_compile_opts, []) ++ + rebar_utils:erl_opts(State), + TestOpts = [{outdir, TmpDir}] ++ + add_test_dir(ErlOpts) ++ + safe_define_test_macro(ErlOpts), + rebar_state:set(State, erl_opts, TestOpts). + +add_test_dir(Opts) -> + %% if no src_dirs are set we have to specify `src` or it won't + %% be built + case proplists:append_values(src_dirs, Opts) of + [] -> [{src_dirs, ["src", "test"]}]; + _ -> [{src_dirs, ["test"]}] 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_dir: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 + +safe_define_test_macro(Opts) -> + %% defining a compile macro twice results in an exception so + %% make sure 'TEST' is only defined once + case test_defined(Opts) of + true -> Opts; + false -> [{d, 'TEST'}] ++ Opts 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, []); - _ -> - [] + +test_defined([{d, 'TEST'}|_]) -> true; +test_defined([{d, 'TEST', true}|_]) -> true; +test_defined([_|Rest]) -> test_defined(Rest); +test_defined([]) -> false. + +first_files(State) -> + BaseFirst = rebar_state:get(State, erl_first_files, []), + EUnitFirst = rebar_state:get(State, eunit_first_files, []), + rebar_state:set(State, erl_first_modules, BaseFirst ++ EUnitFirst). + +resolve_eunit_opts(State, Opts) -> + EUnitOpts = rebar_state:get(State, eunit_opts, []), + case lists:member({verbose, true}, Opts) of + true -> set_verbose(EUnitOpts); + false -> EUnitOpts 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) + +set_verbose(Opts) -> + case lists:member(verbose, Opts) of + true -> Opts; + false -> [verbose] ++ Opts end. + +handle_results(ok) -> ok; +handle_results(error) -> + {error, unknown_error}; +handle_results({error, Reason}) -> + {error, {error_running_tests, Reason}}. + -- cgit v1.1 From 84dc8c935730562599e6dc5f32d0eac099d9d542 Mon Sep 17 00:00:00 2001 From: alisdair sullivan Date: Tue, 16 Dec 2014 17:24:58 -0800 Subject: reworked ct provider compiles common test files in a temporary dir (or a user specified dir) and runs tests without leaving artifacts in the source tree precompile tests using `rebar.config` and disable autocompile so project specific options are used fixes #62 --- src/rebar_prv_common_test.erl | 215 ++++++++++++++++++++++++++---------------- 1 file changed, 133 insertions(+), 82 deletions(-) (limited to 'src') diff --git a/src/rebar_prv_common_test.erl b/src/rebar_prv_common_test.erl index 4576d05..ceab16c 100644 --- a/src/rebar_prv_common_test.erl +++ b/src/rebar_prv_common_test.erl @@ -25,19 +25,41 @@ init(State) -> {deps, ?DEPS}, {bare, false}, {example, "rebar ct"}, - {short_desc, "Run Common Tests"}, + {short_desc, "Run Common Tests."}, {desc, ""}, {opts, ct_opts(State)}, {profile, test}]), State1 = rebar_state:add_provider(State, Provider), {ok, State1}. --spec do(rebar_state:t()) -> {ok, rebar_state:t()}. +-spec do(rebar_state:t()) -> {ok, rebar_state:t()} | {error, string()}. do(State) -> - {Opts, _} = rebar_state:command_parsed_args(State), - Opts1 = transform_opts(Opts), - ok = create_dirs(Opts1), - case handle_results(ct:run_test(Opts1)) of + ?INFO("Running Common Test suites...", []), + {RawOpts, _} = rebar_state:command_parsed_args(State), + Opts = [{auto_compile, false}] ++ transform_opts(RawOpts), + ProjectApps = rebar_state:project_apps(State), + OutDir = case proplists:get_value(outdir, RawOpts, undefined) of + undefined -> filename:join([rebar_state:dir(State), + ec_file:insecure_mkdtemp()]); + Path -> Path + end, + InDir = proplists:get_value(dir, Opts, []), + ok = create_dirs(Opts), + ?DEBUG("Compiling Common Test suites in: ~p", [OutDir]), + lists:foreach(fun(App) -> + AppDir = rebar_app_info:dir(App), + C = rebar_config:consult(AppDir), + S = rebar_state:new(State, C, AppDir), + %% combine `erl_first_files` and `common_test_first_files` and + %% adjust compile opts to include `common_test_compile_opts` + %% and `{src_dirs, "test"}` + TestState = first_files(test_opts(S, InDir, OutDir)), + ok = rebar_erlc_compiler:compile(TestState, AppDir) + end, ProjectApps), + true = code:add_patha(OutDir), + CTOpts = resolve_ct_opts(State, Opts), + Result = handle_results(ct:run_test([{dir, OutDir}] ++ CTOpts)), + case Result of {error, Reason} -> {error, {?MODULE, Reason}}; ok -> @@ -51,9 +73,9 @@ format_error({error_running_tests, Reason}) -> io_lib:format("Error running tests: ~p", [Reason]). ct_opts(State) -> - DefaultTestDir = filename:join([rebar_state:dir(State), "test"]), DefaultLogsDir = filename:join([rebar_state:dir(State), "logs"]), - [{dir, undefined, "dir", {string, DefaultTestDir}, help(dir)}, %% dir + [{dir, undefined, "dir", string, help(dir)}, %% comma-seperated list + {outdir, undefined, "outdir", string, help(outdir)}, %% string {suite, undefined, "suite", string, help(suite)}, %% comma-seperated list {group, undefined, "group", string, help(group)}, %% comma-seperated list {testcase, undefined, "case", string, help(testcase)}, %% comma-seperated list @@ -63,7 +85,7 @@ ct_opts(State) -> {config, undefined, "config", string, help(config)}, %% comma-seperated list {userconfig, undefined, "userconfig", string, help(userconfig)}, %% [{CallbackMod, CfgStrings}] | {CallbackMod, CfgStrings} {allow_user_terms, undefined, "allow_user_terms", boolean, help(allow_user_terms)}, %% Bool - {logdir, undefined, "logdir", {string, DefaultLogsDir}, help(logdir)}, %% string + {logdir, undefined, "logdir", {string, DefaultLogsDir}, help(logdir)}, %% dir {logopts, undefined, "logopts", string, help(logopts)}, %% enum, no_nl | no_src {verbosity, undefined, "verbosity", string, help(verbosity)}, %% Integer OR [{Category, VLevel}] {silent_connections, undefined, "silent_connections", string, @@ -87,10 +109,74 @@ ct_opts(State) -> {ct_hooks, undefined, "ct_hooks", string, help(ct_hooks)} %% List: [CTHModule | {CTHModule, CTHInitArgs}] where CTHModule is atom CthInitArgs is term ]. +help(outdir) -> + "Output directory for compiled modules"; +help(dir) -> + "List of directories containing test suites (default: test)"; +help(suite) -> + "List of test suites to run"; +help(group) -> + "List of test groups to run"; +help(testcase) -> + "List of test cases to run"; +help(spec) -> + "List of test specs to run"; +help(join_specs) -> + ""; %% ?? +help(label) -> + "Test label"; +help(config) -> + "List of config files"; +help(allow_user_terms) -> + ""; %% ?? +help(logdir) -> + "Log folder"; +help(logopts) -> + ""; %% ?? +help(verbosity) -> + "Verbosity"; +help(silent_connections) -> + ""; %% ?? +help(stylesheet) -> + "Stylesheet to use for test results"; +help(cover) -> + "Cover file to use"; +help(cover_stop) -> + ""; %% ?? +help(event_handler) -> + "Event handlers to attach to the runner"; +help(include) -> + "Include folder"; +help(abort_if_missing_suites) -> + "Abort if suites are missing"; +help(multiply_timetraps) -> + ""; %% ?? +help(scale_timetraps) -> + ""; %% ?? +help(create_priv_dir) -> + ""; %% ?? +help(repeat) -> + "How often to repeat tests"; +help(duration) -> + "Max runtime (format: HHMMSS)"; +help(until) -> + "Run until (format: HHMMSS)"; +help(force_stop) -> + "Force stop after time"; +help(basic_html) -> + "Show basic HTML"; +help(ct_hooks) -> + ""; +help(userconfig) -> + "". + transform_opts(Opts) -> transform_opts(Opts, []). transform_opts([], Acc) -> Acc; +%% drop `outdir` so it's not passed to common_test +transform_opts([{outdir, _}|Rest], Acc) -> + transform_opts(Rest, Acc); transform_opts([{ct_hooks, CtHooks}|Rest], Acc) -> transform_opts(Rest, [{ct_hooks, parse_term(CtHooks)}|Acc]); transform_opts([{force_stop, "skip_rest"}|Rest], Acc) -> @@ -155,86 +241,51 @@ parse_term(String) -> create_dirs(Opts) -> LogDir = proplists:get_value(logdir, Opts), - TestDir = proplists:get_value(dir, Opts), - ensure_logdir(LogDir), - ensure_testdir(TestDir), + ensure_dir([LogDir]), ok. -ensure_logdir(Logdir) -> - case ec_file:is_dir(Logdir) of +ensure_dir([]) -> ok; +ensure_dir([Dir|Rest]) -> + case ec_file:is_dir(Dir) of true -> ok; false -> - ec_file:mkdir_path(Logdir) - end. + ec_file:mkdir_path(Dir) + end, + ensure_dir(Rest). -ensure_testdir(Testdir) -> - case ec_file:is_dir(Testdir) of - false -> - ?INFO("Test directory ~s does not exist:\n", - [Testdir]), - ?FAIL; - _ -> ok - end. +test_opts(State, InDir, OutDir) -> + ErlOpts = rebar_state:get(State, common_test_compile_opts, []) ++ + rebar_utils:erl_opts(State), + TestOpts = [{outdir, OutDir}] ++ + [{src_dirs, InDir}] ++ + [{src_dirs, ["src", "test"]}] ++ + ErlOpts, + rebar_state:set(State, erl_opts, TestOpts). -help(dir) -> - "Test folder (default: test/)"; -help(suite) -> - "List of test suites to run"; -help(group) -> - "List of test groups to run"; -help(testcase) -> - "List of test cases to run"; -help(spec) -> - "List of test specs to run"; -help(join_specs) -> - ""; %% ?? -help(label) -> - "Test label"; -help(config) -> - "List of config files"; -help(allow_user_terms) -> - ""; %% ?? -help(logdir) -> - "Log folder"; -help(logopts) -> - ""; %% ?? -help(verbosity) -> - "Verbosity"; -help(silent_connections) -> - ""; %% ?? -help(stylesheet) -> - "Stylesheet to use for test results"; -help(cover) -> - "Cover file to use"; -help(cover_stop) -> - ""; %% ?? -help(event_handler) -> - "Event handlers to attach to the runner"; -help(include) -> - "Include folder"; -help(abort_if_missing_suites) -> - "Abort if suites are missing"; -help(multiply_timetraps) -> - ""; %% ?? -help(scale_timetraps) -> - ""; %% ?? -help(create_priv_dir) -> - ""; %% ?? -help(repeat) -> - "How often to repeat tests"; -help(duration) -> - "Max runtime (format: HHMMSS)"; -help(until) -> - "Run until (format: HHMMSS)"; -help(force_stop) -> - "Force stop after time"; -help(basic_html) -> - "Show basic HTML"; -help(ct_hooks) -> - ""; -help(userconfig) -> - "". +first_files(State) -> + BaseFirst = rebar_state:get(State, erl_first_files, []), + CTFirst = rebar_state:get(State, common_test_first_files, []), + rebar_state:set(State, erl_first_modules, BaseFirst ++ CTFirst). + +resolve_ct_opts(State, Opts) -> + CTOpts = rebar_state:get(State, common_test_opts, []), + %% rebar has seperate input and output directories whereas `common_test` + %% uses only a single directory so handle `dir` elsewhere + CmdLineOpts = lists:keydelete(dir, 1, Opts), + merge_opts(CTOpts, CmdLineOpts, []). + +%% merge opts by iterating over opts defined in `rebar.config` and checking +%% command line opts to see if opt is also defined there. if so, take that +%% value (dropping the value from `rebar.config`) and continue until there +%% are no more opts defined in `rebar.config` then append remaining command +%% line opts +merge_opts([], CmdLineOpts, Acc) -> [CmdLineOpts] ++ Acc; +merge_opts([{K, V}|Rest], CmdLineOpts, Acc) -> + case lists:keytake(K, 1, CmdLineOpts) of + {K, Override, Rem} -> merge_opts(Rest, Rem, [{K, Override}] ++ Acc); + false -> merge_opts(Rest, CmdLineOpts, [{K, V}] ++ Acc) + end. handle_results([Result]) -> handle_results(Result); -- cgit v1.1 From e5270da3d751605fbb6fbcdfd12ad0d76e1fcfbd Mon Sep 17 00:00:00 2001 From: alisdair sullivan Date: Wed, 7 Jan 2015 17:59:07 -0800 Subject: preserve rebar path when running `ct` and `eunit` tests --- src/rebar_prv_common_test.erl | 4 +++- src/rebar_prv_eunit.erl | 7 +++++-- 2 files changed, 8 insertions(+), 3 deletions(-) (limited to 'src') diff --git a/src/rebar_prv_common_test.erl b/src/rebar_prv_common_test.erl index ceab16c..65a09ef 100644 --- a/src/rebar_prv_common_test.erl +++ b/src/rebar_prv_common_test.erl @@ -41,7 +41,7 @@ do(State) -> OutDir = case proplists:get_value(outdir, RawOpts, undefined) of undefined -> filename:join([rebar_state:dir(State), ec_file:insecure_mkdtemp()]); - Path -> Path + Out -> Out end, InDir = proplists:get_value(dir, Opts, []), ok = create_dirs(Opts), @@ -56,9 +56,11 @@ do(State) -> TestState = first_files(test_opts(S, InDir, OutDir)), ok = rebar_erlc_compiler:compile(TestState, AppDir) end, ProjectApps), + Path = code:get_path(), true = code:add_patha(OutDir), CTOpts = resolve_ct_opts(State, Opts), Result = handle_results(ct:run_test([{dir, OutDir}] ++ CTOpts)), + true = code:set_path(Path), case Result of {error, Reason} -> {error, {?MODULE, Reason}}; diff --git a/src/rebar_prv_eunit.erl b/src/rebar_prv_eunit.erl index cb0e850..7db11a3 100644 --- a/src/rebar_prv_eunit.erl +++ b/src/rebar_prv_eunit.erl @@ -41,7 +41,7 @@ do(State) -> OutDir = case proplists:get_value(outdir, Opts, undefined) of undefined -> filename:join([rebar_state:dir(State), ec_file:insecure_mkdtemp()]); - Path -> Path + Out -> Out end, ?DEBUG("Compiling EUnit instrumented modules in: ~p", [OutDir]), lists:foreach(fun(App) -> @@ -54,11 +54,14 @@ do(State) -> TestState = first_files(test_opts(S, OutDir)), ok = rebar_erlc_compiler:compile(TestState, AppDir) end, ProjectApps), + Path = code:get_path(), true = code:add_patha(OutDir), EUnitOpts = resolve_eunit_opts(State, Opts), AppsToTest = [{application, erlang:binary_to_atom(rebar_app_info:name(App), unicode)} || App <- ProjectApps], - case handle_results(eunit:test(AppsToTest, EUnitOpts)) of + Result = eunit:test(AppsToTest, EUnitOpts), + true = code:set_path(Path), + case handle_results(Result) of {error, Reason} -> {error, {?MODULE, Reason}}; ok -> -- cgit v1.1 From f4dafa4628da045db7b21c90406138baccd7b844 Mon Sep 17 00:00:00 2001 From: alisdair sullivan Date: Wed, 7 Jan 2015 18:31:27 -0800 Subject: switch to `lists:ukeymerge` to merge `ct` opts for better behavior in presence of keys defined multiple times --- src/rebar_prv_common_test.erl | 14 +------------- 1 file changed, 1 insertion(+), 13 deletions(-) (limited to 'src') diff --git a/src/rebar_prv_common_test.erl b/src/rebar_prv_common_test.erl index 65a09ef..50c7cf0 100644 --- a/src/rebar_prv_common_test.erl +++ b/src/rebar_prv_common_test.erl @@ -275,19 +275,7 @@ resolve_ct_opts(State, Opts) -> %% rebar has seperate input and output directories whereas `common_test` %% uses only a single directory so handle `dir` elsewhere CmdLineOpts = lists:keydelete(dir, 1, Opts), - merge_opts(CTOpts, CmdLineOpts, []). - -%% merge opts by iterating over opts defined in `rebar.config` and checking -%% command line opts to see if opt is also defined there. if so, take that -%% value (dropping the value from `rebar.config`) and continue until there -%% are no more opts defined in `rebar.config` then append remaining command -%% line opts -merge_opts([], CmdLineOpts, Acc) -> [CmdLineOpts] ++ Acc; -merge_opts([{K, V}|Rest], CmdLineOpts, Acc) -> - case lists:keytake(K, 1, CmdLineOpts) of - {K, Override, Rem} -> merge_opts(Rest, Rem, [{K, Override}] ++ Acc); - false -> merge_opts(Rest, CmdLineOpts, [{K, V}] ++ Acc) - end. + lists:ukeymerge(1, lists:ukeysort(1, CmdLineOpts), lists:ukeysort(1, CTOpts)). handle_results([Result]) -> handle_results(Result); -- cgit v1.1 From fc2cd7395576c6d4cb8047f4589a481c596b8f4e Mon Sep 17 00:00:00 2001 From: alisdair sullivan Date: Thu, 8 Jan 2015 00:27:45 -0800 Subject: add `eunit` and `common_test` to `applications` key of `rebar.app` --- src/rebar.app.src | 2 ++ 1 file changed, 2 insertions(+) (limited to 'src') diff --git a/src/rebar.app.src b/src/rebar.app.src index 1a1e528..73c1eff 100644 --- a/src/rebar.app.src +++ b/src/rebar.app.src @@ -13,6 +13,8 @@ crypto, syntax_tools, tools, + eunit, + common_test, erlware_commons, providers, relx, -- cgit v1.1 From 99732ae4f37c406b9c2772b5de5013ee13c9099a Mon Sep 17 00:00:00 2001 From: alisdair sullivan Date: Thu, 8 Jan 2015 12:43:38 -0800 Subject: adjust handling of `common_test` `dir` option and refactor provider option handling --- src/rebar_prv_common_test.erl | 52 +++++++++++++++++++++++++++---------------- 1 file changed, 33 insertions(+), 19 deletions(-) (limited to 'src') diff --git a/src/rebar_prv_common_test.erl b/src/rebar_prv_common_test.erl index 50c7cf0..2cdef33 100644 --- a/src/rebar_prv_common_test.erl +++ b/src/rebar_prv_common_test.erl @@ -36,14 +36,9 @@ init(State) -> do(State) -> ?INFO("Running Common Test suites...", []), {RawOpts, _} = rebar_state:command_parsed_args(State), - Opts = [{auto_compile, false}] ++ transform_opts(RawOpts), + {InDirs, OutDir} = split_ct_dirs(State, RawOpts), + Opts = transform_opts(RawOpts), ProjectApps = rebar_state:project_apps(State), - OutDir = case proplists:get_value(outdir, RawOpts, undefined) of - undefined -> filename:join([rebar_state:dir(State), - ec_file:insecure_mkdtemp()]); - Out -> Out - end, - InDir = proplists:get_value(dir, Opts, []), ok = create_dirs(Opts), ?DEBUG("Compiling Common Test suites in: ~p", [OutDir]), lists:foreach(fun(App) -> @@ -53,13 +48,13 @@ do(State) -> %% combine `erl_first_files` and `common_test_first_files` and %% adjust compile opts to include `common_test_compile_opts` %% and `{src_dirs, "test"}` - TestState = first_files(test_opts(S, InDir, OutDir)), + TestState = test_state(S, InDirs, OutDir), ok = rebar_erlc_compiler:compile(TestState, AppDir) end, ProjectApps), Path = code:get_path(), true = code:add_patha(OutDir), - CTOpts = resolve_ct_opts(State, Opts), - Result = handle_results(ct:run_test([{dir, OutDir}] ++ CTOpts)), + CTOpts = resolve_ct_opts(State, Opts, OutDir), + Result = handle_results(ct:run_test(CTOpts)), true = code:set_path(Path), case Result of {error, Reason} -> @@ -114,7 +109,7 @@ ct_opts(State) -> help(outdir) -> "Output directory for compiled modules"; help(dir) -> - "List of directories containing test suites (default: test)"; + "List of additional directories containing test suites"; help(suite) -> "List of test suites to run"; help(group) -> @@ -172,6 +167,23 @@ help(ct_hooks) -> help(userconfig) -> "". +split_ct_dirs(State, RawOpts) -> + %% preserve the override nature of command line opts by only checking + %% `rebar.config` defined additional test dirs if none are defined via + %% command line flag + InDirs = case proplists:get_value(dir, RawOpts) of + undefined -> + CTOpts = rebar_state:get(State, common_test_opts, []), + proplists:get_value(dir, CTOpts, []); + Dirs -> split_string(Dirs) + end, + OutDir = case proplists:get_value(outdir, RawOpts) of + undefined -> filename:join([rebar_state:dir(State), + ec_file:insecure_mkdtemp()]); + Out -> Out + end, + {InDirs, OutDir}. + transform_opts(Opts) -> transform_opts(Opts, []). @@ -256,26 +268,28 @@ ensure_dir([Dir|Rest]) -> end, ensure_dir(Rest). -test_opts(State, InDir, OutDir) -> +test_state(State, InDirs, OutDir) -> ErlOpts = rebar_state:get(State, common_test_compile_opts, []) ++ rebar_utils:erl_opts(State), TestOpts = [{outdir, OutDir}] ++ - [{src_dirs, InDir}] ++ - [{src_dirs, ["src", "test"]}] ++ + [{src_dirs, ["src", "test"] ++ InDirs}] ++ ErlOpts, - rebar_state:set(State, erl_opts, TestOpts). + first_files(rebar_state:set(State, erl_opts, TestOpts)). first_files(State) -> BaseFirst = rebar_state:get(State, erl_first_files, []), CTFirst = rebar_state:get(State, common_test_first_files, []), rebar_state:set(State, erl_first_modules, BaseFirst ++ CTFirst). -resolve_ct_opts(State, Opts) -> +resolve_ct_opts(State, CmdLineOpts, OutDir) -> CTOpts = rebar_state:get(State, common_test_opts, []), + Opts = lists:ukeymerge(1, + lists:ukeysort(1, CmdLineOpts), + lists:ukeysort(1, CTOpts)), %% rebar has seperate input and output directories whereas `common_test` - %% uses only a single directory so handle `dir` elsewhere - CmdLineOpts = lists:keydelete(dir, 1, Opts), - lists:ukeymerge(1, lists:ukeysort(1, CmdLineOpts), lists:ukeysort(1, CTOpts)). + %% uses only a single directory so set `dir` to our precompiled `OutDir` + %% and disable `auto_compile` + [{auto_compile, false}, {dir, OutDir}] ++ lists:keydelete(dir, 1, Opts). handle_results([Result]) -> handle_results(Result); -- cgit v1.1 From 853efc50770b9c79795184575420212da7f7ddf7 Mon Sep 17 00:00:00 2001 From: alisdair sullivan Date: Thu, 8 Jan 2015 13:08:27 -0800 Subject: exclude `_checkouts` from directories to be precompiled for `common_test` and `eunit` providers --- src/rebar_prv_common_test.erl | 15 +++++++++++++-- src/rebar_prv_eunit.erl | 17 ++++++++++++++--- 2 files changed, 27 insertions(+), 5 deletions(-) (limited to 'src') diff --git a/src/rebar_prv_common_test.erl b/src/rebar_prv_common_test.erl index 2cdef33..46d3240 100644 --- a/src/rebar_prv_common_test.erl +++ b/src/rebar_prv_common_test.erl @@ -38,7 +38,7 @@ do(State) -> {RawOpts, _} = rebar_state:command_parsed_args(State), {InDirs, OutDir} = split_ct_dirs(State, RawOpts), Opts = transform_opts(RawOpts), - ProjectApps = rebar_state:project_apps(State), + TestApps = filter_checkouts(rebar_state:project_apps(State)), ok = create_dirs(Opts), ?DEBUG("Compiling Common Test suites in: ~p", [OutDir]), lists:foreach(fun(App) -> @@ -50,7 +50,7 @@ do(State) -> %% and `{src_dirs, "test"}` TestState = test_state(S, InDirs, OutDir), ok = rebar_erlc_compiler:compile(TestState, AppDir) - end, ProjectApps), + end, TestApps), Path = code:get_path(), true = code:add_patha(OutDir), CTOpts = resolve_ct_opts(State, Opts, OutDir), @@ -253,6 +253,17 @@ parse_term(String) -> Term end. +filter_checkouts(Apps) -> filter_checkouts(Apps, []). + +filter_checkouts([], Acc) -> lists:reverse(Acc); +filter_checkouts([App|Rest], Acc) -> + AppDir = filename:absname(rebar_app_info:dir(App)), + CheckoutsDir = filename:absname("_checkouts"), + case lists:prefix(CheckoutsDir, AppDir) of + true -> filter_checkouts(Rest, Acc); + false -> filter_checkouts(Rest, [App|Acc]) + end. + create_dirs(Opts) -> LogDir = proplists:get_value(logdir, Opts), ensure_dir([LogDir]), diff --git a/src/rebar_prv_eunit.erl b/src/rebar_prv_eunit.erl index 7db11a3..499a04f 100644 --- a/src/rebar_prv_eunit.erl +++ b/src/rebar_prv_eunit.erl @@ -37,7 +37,7 @@ do(State) -> ?INFO("Performing EUnit tests...", []), {RawOpts, _} = rebar_state:command_parsed_args(State), Opts = transform_opts(RawOpts, State), - ProjectApps = rebar_state:project_apps(State), + TestApps = filter_checkouts(rebar_state:project_apps(State)), OutDir = case proplists:get_value(outdir, Opts, undefined) of undefined -> filename:join([rebar_state:dir(State), ec_file:insecure_mkdtemp()]); @@ -53,12 +53,12 @@ do(State) -> %% and `{src_dirs, "test"}` TestState = first_files(test_opts(S, OutDir)), ok = rebar_erlc_compiler:compile(TestState, AppDir) - end, ProjectApps), + end, TestApps), Path = code:get_path(), true = code:add_patha(OutDir), EUnitOpts = resolve_eunit_opts(State, Opts), AppsToTest = [{application, erlang:binary_to_atom(rebar_app_info:name(App), unicode)} - || App <- ProjectApps], + || App <- TestApps], Result = eunit:test(AppsToTest, EUnitOpts), true = code:set_path(Path), case handle_results(Result) of @@ -93,6 +93,17 @@ transform_opts([{outdir, Path}|Rest], State, Acc) -> transform_opts([{Key, Val}|Rest], State, Acc) -> transform_opts(Rest, State, [{Key, Val}|Acc]). +filter_checkouts(Apps) -> filter_checkouts(Apps, []). + +filter_checkouts([], Acc) -> lists:reverse(Acc); +filter_checkouts([App|Rest], Acc) -> + AppDir = filename:absname(rebar_app_info:dir(App)), + CheckoutsDir = filename:absname("_checkouts"), + case lists:prefix(CheckoutsDir, AppDir) of + true -> filter_checkouts(Rest, Acc); + false -> filter_checkouts(Rest, [App|Acc]) + end. + test_opts(State, TmpDir) -> ErlOpts = rebar_state:get(State, eunit_compile_opts, []) ++ rebar_utils:erl_opts(State), -- cgit v1.1 From 16c31097c2616d1fb0038b065956c1f6442e339c Mon Sep 17 00:00:00 2001 From: alisdair sullivan Date: Thu, 8 Jan 2015 15:50:15 -0800 Subject: add support for a bare `test` directory when using `apps` libdirs --- src/rebar_prv_common_test.erl | 28 ++++++++++++++++++++++++++-- src/rebar_prv_eunit.erl | 31 ++++++++++++++++++++++++------- 2 files changed, 50 insertions(+), 9 deletions(-) (limited to 'src') diff --git a/src/rebar_prv_common_test.erl b/src/rebar_prv_common_test.erl index 46d3240..7a52c92 100644 --- a/src/rebar_prv_common_test.erl +++ b/src/rebar_prv_common_test.erl @@ -51,6 +51,7 @@ do(State) -> TestState = test_state(S, InDirs, OutDir), ok = rebar_erlc_compiler:compile(TestState, AppDir) end, TestApps), + ok = maybe_compile_extra_tests(TestApps, State, InDirs, OutDir), Path = code:get_path(), true = code:add_patha(OutDir), CTOpts = resolve_ct_opts(State, Opts, OutDir), @@ -283,10 +284,17 @@ test_state(State, InDirs, OutDir) -> ErlOpts = rebar_state:get(State, common_test_compile_opts, []) ++ rebar_utils:erl_opts(State), TestOpts = [{outdir, OutDir}] ++ - [{src_dirs, ["src", "test"] ++ InDirs}] ++ - ErlOpts, + add_test_dir(ErlOpts, InDirs), first_files(rebar_state:set(State, erl_opts, TestOpts)). +add_test_dir(Opts, InDirs) -> + %% if no src_dirs are set we have to specify `src` or it won't + %% be built + case proplists:append_values(src_dirs, Opts) of + [] -> [{src_dirs, ["src", "test"|InDirs]}]; + _ -> [{src_dirs, ["test"|InDirs]}] + end. + first_files(State) -> BaseFirst = rebar_state:get(State, erl_first_files, []), CTFirst = rebar_state:get(State, common_test_first_files, []), @@ -302,6 +310,22 @@ resolve_ct_opts(State, CmdLineOpts, OutDir) -> %% and disable `auto_compile` [{auto_compile, false}, {dir, OutDir}] ++ lists:keydelete(dir, 1, Opts). +maybe_compile_extra_tests(TestApps, State, InDirs, OutDir) -> + F = fun(App) -> rebar_app_info:dir(App) == rebar_dir:get_cwd() end, + case lists:filter(F, TestApps) of + %% compile just the `test` and extra test directories of the base dir + [] -> + ErlOpts = rebar_state:get(State, common_test_compile_opts, []) ++ + rebar_utils:erl_opts(State), + TestOpts = [{outdir, OutDir}] ++ + [{src_dirs, ["test"|InDirs]}] ++ + lists:keydelete(src_dirs, 1, ErlOpts), + TestState = first_files(rebar_state:set(State, erl_opts, TestOpts)), + rebar_erlc_compiler:compile(TestState, rebar_dir:get_cwd()); + %% already compiled `./test` so do nothing + _ -> ok + end. + handle_results([Result]) -> handle_results(Result); handle_results([Result|Results]) when is_list(Results) -> diff --git a/src/rebar_prv_eunit.erl b/src/rebar_prv_eunit.erl index 499a04f..ee8a235 100644 --- a/src/rebar_prv_eunit.erl +++ b/src/rebar_prv_eunit.erl @@ -51,9 +51,10 @@ do(State) -> %% combine `erl_first_files` and `eunit_first_files` and adjust %% compile opts to include `eunit_compile_opts`, `{d, 'TEST'}` %% and `{src_dirs, "test"}` - TestState = first_files(test_opts(S, OutDir)), + TestState = first_files(test_state(S, OutDir)), ok = rebar_erlc_compiler:compile(TestState, AppDir) end, TestApps), + ok = maybe_compile_extra_tests(TestApps, State, OutDir), Path = code:get_path(), true = code:add_patha(OutDir), EUnitOpts = resolve_eunit_opts(State, Opts), @@ -104,12 +105,12 @@ filter_checkouts([App|Rest], Acc) -> false -> filter_checkouts(Rest, [App|Acc]) end. -test_opts(State, TmpDir) -> +test_state(State, TmpDir) -> ErlOpts = rebar_state:get(State, eunit_compile_opts, []) ++ rebar_utils:erl_opts(State), - TestOpts = [{outdir, TmpDir}] ++ - add_test_dir(ErlOpts) ++ - safe_define_test_macro(ErlOpts), + ErlOpts1 = [{outdir, TmpDir}] ++ + add_test_dir(ErlOpts), + TestOpts = safe_define_test_macro(ErlOpts1), rebar_state:set(State, erl_opts, TestOpts). add_test_dir(Opts) -> @@ -117,8 +118,8 @@ add_test_dir(Opts) -> %% be built case proplists:append_values(src_dirs, Opts) of [] -> [{src_dirs, ["src", "test"]}]; - _ -> [{src_dirs, ["test"]}] - end. + Srcs -> [{src_dirs, ["test"|Srcs]}] + end ++ lists:keydelete(src_dirs, 1, Opts). safe_define_test_macro(Opts) -> %% defining a compile macro twice results in an exception so @@ -151,6 +152,22 @@ set_verbose(Opts) -> false -> [verbose] ++ Opts end. +maybe_compile_extra_tests(TestApps, State, OutDir) -> + F = fun(App) -> rebar_app_info:dir(App) == rebar_dir:get_cwd() end, + case lists:filter(F, TestApps) of + %% compile just the `test` and extra test directories of the base dir + [] -> + ErlOpts = rebar_state:get(State, common_test_compile_opts, []) ++ + rebar_utils:erl_opts(State), + TestOpts = [{outdir, OutDir}] ++ + [{src_dirs, ["test"]}] ++ + safe_define_test_macro(lists:keydelete(src_dirs, 1, ErlOpts)), + TestState = first_files(rebar_state:set(State, erl_opts, TestOpts)), + rebar_erlc_compiler:compile(TestState, rebar_dir:get_cwd()); + %% already compiled `./test` so do nothing + _ -> ok + end. + handle_results(ok) -> ok; handle_results(error) -> {error, unknown_error}; -- cgit v1.1