Merge pull request #7 from edgurgel/cover

Cover

Author: edgurgel

.travis.yml

@@ -1,13 +1,13 @@
 sudo: false
 language: elixir
 elixir:
-  - 1.7
   - 1.8
   - 1.9
 otp_release:
   - 21.0
   - 22.0
 script:
   - mix test
+  - mix test --cover
   - mix format --check-formatted
   - mix credo --strict

lib/mimic.ex

@@ -335,8 +335,8 @@ defmodule Mimic do
             "Module #{inspect(module)} is not available"
     end
 
-    original_module = Mimic.Module.original(module)
-    Mimic.Module.replace!(module, original_module)
+    Mimic.Module.replace!(module)
+    ExUnit.after_suite(fn _ -> Server.reset(module) end)
 
     :ok
   end

lib/mimic/application.ex

@@ -1,9 +1,10 @@
 defmodule Mimic.Application do
   use Application
-  alias Mimic.Server
+  alias Mimic.{Cover, Server}
   @moduledoc false
 
   def start(_, _) do
+    Cover.export_private_functions()
     children = [Server]
     Supervisor.start_link(children, name: Mimic.Supervisor, strategy: :one_for_one)
   end

lib/mimic/cover.ex

@@ -0,0 +1,81 @@
+defmodule Mimic.Cover do
+  @moduledoc """
+  Abuse cover private functions to move stuff around
+  Completely based on meck's solution:
+  https://github.com/eproxus/meck/blob/2c7ba603416e95401500d7e116c5a829cb558665/src/meck_cover.erl#L67-L91
+  """
+
+  @doc false
+  def export_private_functions do
+    {_, binary, _} = :code.get_object_code(:cover)
+    {:ok, {_, [{_, {_, abstract_code}}]}} = :beam_lib.chunks(binary, [:abstract_code])
+    {:ok, module, binary} = :compile.forms(abstract_code, [:export_all])
+    :code.load_binary(module, '', binary)
+  end
+
+  @doc false
+  def replace_coverdata!(module, original_beam, original_coverdata) do
+    original_module = Mimic.Module.original(module)
+    path = export_coverdata!(original_module)
+    rewrite_coverdata!(path, module)
+    Mimic.Module.clear!(module)
+    :cover.compile_beam(original_beam)
+    :ok = :cover.import(path)
+    :ok = :cover.import(original_coverdata)
+    File.rm(path)
+    File.rm(original_coverdata)
+  end
+
+  @doc false
+  def export_coverdata!(module) do
+    path = Path.expand("#{module}-#{:os.getpid()}.coverdata", ".")
+    :ok = :cover.export(path, module)
+    path
+  end
+
+  defp rewrite_coverdata!(path, module) do
+    terms = get_terms(path)
+    terms = replace_module_name(terms, module)
+    write_coverdata!(path, terms)
+  end
+
+  defp replace_module_name(terms, module) do
+    Enum.map(terms, fn term -> do_replace_module_name(term, module) end)
+  end
+
+  defp do_replace_module_name({:file, old, file}, module) do
+    {:file, module, String.replace(file, to_string(old), to_string(module))}
+  end
+
+  defp do_replace_module_name({bump = {:bump, _mod, _, _, _, _}, value}, module) do
+    {put_elem(bump, 1, module), value}
+  end
+
+  defp do_replace_module_name({_mod, clauses}, module) do
+    {module, replace_module_name(clauses, module)}
+  end
+
+  defp do_replace_module_name(clause = {_mod, _, _, _, _}, module) do
+    put_elem(clause, 0, module)
+  end
+
+  defp get_terms(path) do
+    {:ok, resource} = File.open(path, [:binary, :read, :raw])
+    terms = get_terms(resource, [])
+    File.close(resource)
+    terms
+  end
+
+  defp get_terms(resource, terms) do
+    case apply(:cover, :get_term, [resource]) do
+      :eof -> terms
+      term -> get_terms(resource, [term | terms])
+    end
+  end
+
+  defp write_coverdata!(path, terms) do
+    {:ok, resource} = File.open(path, [:write, :binary, :raw])
+    Enum.each(terms, fn term -> apply(:cover, :write, [term, resource]) end)
+    File.close(resource)
+  end
+end

lib/mimic/module.ex

@@ -1,17 +1,29 @@
 defmodule Mimic.Module do
-  alias Mimic.Server
+  alias Mimic.{Cover, Server}
   @moduledoc false
 
   def original(module), do: "#{module}.Mimic.Original.Module" |> String.to_atom()
 
   def clear!(module) do
     :code.purge(module)
     :code.delete(module)
-    {:module, ^module} = :code.ensure_loaded(module)
+    :code.purge(original(module))
+    :code.delete(original(module))
     :ok
   end
 
-  def replace!(module, backup_module) do
+  def replace!(module) do
+    backup_module = original(module)
+
+    case :cover.is_compiled(module) do
+      {:file, beam_file} ->
+        coverdata_path = Cover.export_coverdata!(module)
+        Server.store_beam_and_coverdata(module, beam_file, coverdata_path)
+
+      false ->
+        :ok
+    end
+
     rename_module(module, backup_module)
     Code.compiler_options(ignore_module_conflict: true)
     create_mock(module)
@@ -21,42 +33,47 @@ defmodule Mimic.Module do
   end
 
   defp rename_module(module, new_module) do
-    beam_file =
-      case :code.get_object_code(module) do
-        {_, binary, _filename} -> binary
-        _error -> throw({:object_code_not_found, module})
-      end
+    beam_code = beam_code(module)
 
-    result =
-      case :beam_lib.chunks(beam_file, [:abstract_code]) do
-        {:ok, {_, [{:abstract_code, {:raw_abstract_v1, forms}}]}} -> forms
-        {:ok, {_, [{:abstract_code, :no_abstract_code}]}} -> throw(:no_abstract_code)
-      end
+    {:ok, {_, [{:abstract_code, {:raw_abstract_v1, forms}}]}} =
+      :beam_lib.chunks(beam_code, [:abstract_code])
 
-    result =
-      result
-      |> rename_attribute(new_module)
+    forms = rename_attribute(forms, new_module)
 
-    case :compile.forms(result, [:return_errors]) do
+    case :compile.forms(forms, compiler_options(module)) do
       {:ok, module_name, binary} ->
         load_binary(module_name, binary)
         binary
 
       {:ok, module_name, binary, _warnings} ->
         load_binary(module_name, binary)
         Binary
+    end
+  end
 
-      error ->
-        exit({:compile_forms, error})
+  defp beam_code(module) do
+    case :code.get_object_code(module) do
+      {_, binary, _filename} -> binary
+      _error -> throw({:object_code_not_found, module})
     end
   end
 
+  defp compiler_options(module) do
+    options =
+      module.module_info(:compile)
+      |> Keyword.get(:options)
+      |> Enum.filter(&(&1 != :from_core))
+
+    [:return_errors | [:debug_info | options]]
+  end
+
   defp load_binary(module, binary) do
     case :code.load_binary(module, '', binary) do
       {:module, ^module} -> :ok
       {:error, reason} -> exit({:error_loading_module, module, reason})
-      _ -> :yolo
     end
+
+    apply(:cover, :compile_beams, [[{module, binary}]])
   end
 
   defp rename_attribute([{:attribute, line, :module, {_, vars}} | t], new_name) do

lib/mimic/server.ex

@@ -1,5 +1,6 @@
 defmodule Mimic.Server do
   use GenServer
+  alias Mimic.Cover
   @moduledoc false
 
   defmodule State do
@@ -8,7 +9,8 @@ defmodule Mimic.Server do
               mode: :private,
               global_pid: nil,
               stubs: %{},
-              expectations: %{}
+              expectations: %{},
+              modules_beam: %{}
   end
 
   defmodule Expectation do
@@ -52,6 +54,14 @@ defmodule Mimic.Server do
     GenServer.cast(__MODULE__, {:exit, pid})
   end
 
+  def store_beam_and_coverdata(module, beam, coverdata) do
+    GenServer.call(__MODULE__, {:store_beam_and_coverdata, module, beam, coverdata})
+  end
+
+  def reset(module) do
+    GenServer.call(__MODULE__, {:reset, module})
+  end
+
   def apply(module, fn_name, args) do
     arity = Enum.count(args)
     original_module = Mimic.Module.original(module)
@@ -293,6 +303,20 @@ defmodule Mimic.Server do
     {:reply, :ok, %{state | verify_on_exit: MapSet.put(state.verify_on_exit, pid)}}
   end
 
+  def handle_call({:store_beam_and_coverdata, module, beam, coverdata}, _from, state) do
+    modules_beam = Map.put(state.modules_beam, module, {beam, coverdata})
+    {:reply, :ok, %{state | modules_beam: modules_beam}}
+  end
+
+  def handle_call({:reset, module}, _from, state) do
+    case state.modules_beam[module] do
+      {beam, coverdata} -> Cover.replace_coverdata!(module, beam, coverdata)
+      _ -> Mimic.Module.clear!(module)
+    end
+
+    {:reply, :ok, state}
+  end
+
   defp apply_call_to_expectations(
          expectations,
          expectation = %Expectation{num_applied_calls: num_applied_calls, num_calls: num_calls}

mix.exs

@@ -4,15 +4,16 @@ defmodule Mimic.Mixfile do
   def project do
     [
       app: :mimic,
-      version: "1.0.0",
-      elixir: "~> 1.7",
+      version: "1.1.0",
+      elixir: "~> 1.8",
       build_embedded: Mix.env() == :prod,
       start_permanent: Mix.env() == :prod,
       elixirc_paths: elixirc_paths(Mix.env()),
       name: "Mimic",
       description: "Mocks for Elixir functions",
       deps: deps(),
       package: package(),
+      test_coverage: [tool: Mimic.TestCover],
       docs: [extras: ["README.md"], main: "readme"]
     ]
   end

test/support/test_cover.ex

@@ -0,0 +1,33 @@
+defmodule Mimic.TestCover do
+  @moduledoc false
+
+  @doc false
+  def start(compile_path, _opts) do
+    :cover.stop()
+    :cover.start()
+    :cover.compile_beam_directory(compile_path |> String.to_charlist())
+
+    fn ->
+      execute()
+    end
+  end
+
+  defp execute do
+    {:result, results, _fail} = :cover.analyse(:calls, :function)
+
+    results =
+      Enum.filter(results, fn
+        {{Calculator, _, _}, _} -> true
+        _ -> false
+      end)
+
+    expected =
+      {{Calculator, :add, 2}, 5} in results &&
+        {{Calculator, :mult, 2}, 5} in results
+
+    unless expected do
+      IO.puts("Cover results are incorrect!")
+      throw(:test_cover_failed)
+    end
+  end
+end

test/test_helper.exs

@@ -1,3 +1,4 @@
+Calculator.add(2, 3)
 Mimic.copy(Calculator)
 Mimic.copy(Counter)
 ExUnit.start()