PageRenderTime 126ms CodeModel.GetById 0ms RepoModel.GetById 1ms app.codeStats 0ms

/support/run_tests.escript

http://github.com/basho/mochiweb
Unknown | 94 lines | 84 code | 10 blank | 0 comment | 0 complexity | 099880f95868227c84f7995cd5079f2a MD5 | raw file
Possible License(s): MIT 
    

  1. #!/usr/bin/env escript
    2. 

  2. %% -*- erlang -*-
    3. 

  3. %%! -name mochiweb__test@127.0.0.1
    4. 

  4. main([Ebin]) ->
    5. 

  5.     code:add_path(Ebin),
    6. 

  6.     code:add_paths(filelib:wildcard("../deps/*/ebin", Ebin)),
    7. 

  7.     code:add_paths(filelib:wildcard("../deps/*/deps/*/ebin", Ebin)),
    8. 

  8. 

  9.     ModuleNames = [hd(string:tokens(M, "."))
    10. 

  10.                    || "../src/" ++ M <- filelib:wildcard("../src/*.erl")],
    11. 

  11. 

  12.     {ok, NonTestRe} = re:compile("_tests$"),
    13. 

  13.     Modules = [list_to_atom(M) ||
    14. 

  14.                   M <- lists:filter(
    15. 

  15.                          fun(M) ->
    16. 

  16.                                  nomatch == re:run(M, NonTestRe)
    17. 

  17.                          end,
    18. 

  18.                          ModuleNames)],
    19. 

  19. 

  20. 

  21.     crypto:start(),
    22. 

  22.     start_cover(Modules),
    23. 

  23.     eunit:test(Modules, [verbose,{report,{eunit_surefire,[{dir,"../_test"}]}}]),
    24. 

  24.     analyze_cover(Modules);
    25. 

  25. main(_) ->
    26. 

  26.     io:format("usage: run_tests.escript EBIN_DIR~n"),
    27. 

  27.     halt(1).
    28. 

  28. 

  29. start_cover(Modules) ->
    30. 

  30.     {ok, _Cover} = cover:start(),
    31. 

  31.     io:format("Cover compiling...~n"),
    32. 

  32.     Compiled = [ M || {ok, M} <- [ cover:compile(
    33. 

  33.                                      M,
    34. 

  34.                                      [{i, "include"}
    35. 

  35.                                      ])
    36. 

  36.                                    || M <- Modules ] ],
    37. 

  37.     case length(Modules) == length(Compiled) of
    38. 

  38.         true -> ok;
    39. 

  39.         false ->
    40. 

  40.             io:format("Warning: the following modules were not"
    41. 

  41.                       " cover-compiled:~n   ~p~n", [Compiled])
    42. 

  42.     end.
    43. 

  43. 

  44. analyze_cover(Modules) ->
    45. 

  45.     io:format("Analyzing cover...~n"),
    46. 

  46.     CoverBase = filename:join(["..", "_test", "cover"]),
    47. 

  47.     ok = filelib:ensure_dir(filename:join([CoverBase, "fake"])),
    48. 

  48.     Coverages = lists:foldl(
    49. 

  49.                   fun(M, Acc) ->
    50. 

  50.                           [analyze_module(CoverBase, M)|Acc]
    51. 

  51.                   end,
    52. 

  52.                   [], Modules),
    53. 

  53.     IndexFilename = filename:join([CoverBase, "index.html"]),
    54. 

  54.     {ok, Index} = file:open(IndexFilename, [write]),
    55. 

  55.     {LineTotal, CoverTotal} =
    56. 

  56.         lists:foldl(fun({_,_,Lines,Covered}, {LineAcc, CovAcc}) ->
    57. 

  57.                             {LineAcc+Lines, CovAcc+Covered}
    58. 

  58.                     end, {0,0}, Coverages),
    59. 

  59.     file:write(Index,
    60. 

  60.                "<html><head><title>Coverage</title></head>\n"
    61. 

  61.                "<body><h1>Coverage</h1><ul>\n"),
    62. 

  62.     file:write(Index,
    63. 

  63.                io_lib:format("<h2>Total: ~.2f%</h2>\n",
    64. 

  64.                              [percentage(CoverTotal, LineTotal)])),
    65. 

  65.     [ file:write(Index,
    66. 

  66.                  io_lib:format(
    67. 

  67.                    "<li><a href=\"~s\">~p</a>: ~.2f%</li>~n",
    68. 

  68.                    [Filename, Module, percentage(Covered, Lines)]))
    69. 

  69.       || {Filename, Module, Lines, Covered} <- Coverages ],
    70. 

  70.     file:write(Index,"</ul></body></html>"),
    71. 

  71.     file:close(Index),
    72. 

  72.     io:format("Cover analysis in ~s~n", [IndexFilename]).
    73. 

  73. 

  74. analyze_module(CoverBase, Module) ->
    75. 

  75.     {ok, Filename} =
    76. 

  76.         cover:analyze_to_file(
    77. 

  77.           Module,
    78. 

  78.           filename:join(CoverBase, atom_to_list(Module)++".COVER.html"),
    79. 

  79.           [html]),
    80. 

  80.     Lines = count_lines(Filename, "[[:digit:]]\.\.|"),
    81. 

  81.     Covered = count_lines(Filename, "[[:space:]]0\.\.|"),
    82. 

  82.     {filename:basename(Filename), Module, Lines, Lines-Covered}.
    83. 

  83. 

  84. count_lines(Filename, Pattern) ->
    85. 

  85.     {ok, [Lines],_} = io_lib:fread(
    86. 

  86.                         "~d",
    87. 

  87.                         os:cmd(io_lib:format("grep -e \"~s\" ~s | wc -l",
    88. 

  88.                                              [Pattern, Filename]))),
    89. 

  89.     Lines.
    90. 

  90. 

  91. percentage(_, 0) -> 1000.0;
    92. 

  92. percentage(Part, Total) ->
    93. 

  93.     (Part/Total)*100.
    94. 

  94. 

  95.