fix: call_original must have the module already copied

Very rare case where call_original is called before expectations/stubs
are set-up for a module

Author: edgurgel

lib/mimic.ex

@@ -414,6 +414,14 @@ defmodule Mimic do
     arity = length(args)
 
     raise_if_not_exported_function!(module, function_name, arity)
+
+    if Mimic.Module.copied?(module) == false do
+      case Mimic.Server.ensure_copied(module) do
+        :ok -> :ok
+        error -> validate_server_response(error, :call_original)
+      end
+    end
+
     func = Function.capture(Mimic.Module.original(module), function_name, arity)
 
     Kernel.apply(func, args)

lib/mimic/server.ex

@@ -112,6 +112,11 @@ defmodule Mimic.Server do
     GenServer.call(__MODULE__, {:get_calls, {module, fn_name, arity}, self()})
   end
 
+  @spec ensure_copied(module) :: :ok | {:error, {:module_not_copied, module}}
+  def ensure_copied(module) do
+    GenServer.call(__MODULE__, {:ensure_copied, module}, @long_timeout)
+  end
+
   def apply(module, fn_name, args) do
     arity = Enum.count(args)
     original_module = Mimic.Module.original(module)
@@ -575,6 +580,13 @@ defmodule Mimic.Server do
     end
   end
 
+  def handle_call({:ensure_copied, module}, _from, state) do
+    case ensure_module_copied(module, state) do
+      {:ok, new_state} -> {:reply, :ok, new_state}
+      {:error, reason} -> {:reply, {:error, reason}, state}
+    end
+  end
+
   defp maybe_typecheck_func(module, fn_name, func) do
     case module.__mimic_info__() do
       {:ok, %{type_check: true}} ->

test/mimic_test.exs

@@ -1031,6 +1031,24 @@ defmodule Mimic.Test do
   describe "call_original/3" do
     setup :set_mimic_private
 
+    test "calling call_original on a module that has not been copied yet" do
+      module = Mimic.CallOriginalTestModule
+      # Calling copy here but Mimic does not actually copy until Mimic is needed
+      assert_raise ArgumentError,
+                   "Module Mimic.CallOriginalTestModule has not been copied. See docs for Mimic.copy/1",
+                   fn ->
+                     assert Mimic.call_original(module, :my_function, []) ==
+                              :original
+                   end
+
+      Mimic.copy(module)
+      assert Mimic.Module.copied?(module) == false
+      assert Mimic.call_original(module, :my_function, []) == :original
+
+      # call_original should copy the module
+      assert Mimic.Module.copied?(module) == true
+    end
+
     test "calls original function even if it has been is stubbed" do
       stub_with(Calculator, InverseCalculator)
 

test/support/call_original_test_module.ex

@@ -0,0 +1,3 @@
+defmodule Mimic.CallOriginalTestModule do
+  def my_function, do: :original
+end