Better "no expectation found" error (#174)

Author: whatyouhide

lib/mox.ex

@@ -922,19 +922,22 @@ defmodule Mox do
 
   @doc false
   def __dispatch__(mock, name, arity, args) do
-    case fetch_fun_to_dispatch([self() | caller_pids()], {mock, name, arity}) do
+    caller_pids = caller_pids()
+
+    case fetch_fun_to_dispatch([self() | caller_pids], {mock, name, arity}) do
       :no_expectation ->
         mfa = Exception.format_mfa(mock, name, arity)
 
         raise UnexpectedCallError,
-              "no expectation defined for #{mfa} in #{format_process()} with args #{inspect(args)}"
+              "no expectation found for #{mfa} in #{format_process(caller_pids, true)} " <>
+                "with args #{inspect(args)}"
 
       {:out_of_expectations, count} ->
         mfa = Exception.format_mfa(mock, name, arity)
 
         raise UnexpectedCallError,
               "expected #{mfa} to be called #{times(count)} but it has been " <>
-                "called #{times(count + 1)} in #{format_process()}"
+                "called #{times(count + 1)} in #{format_process(caller_pids, false)}"
 
       {:remote, fun_to_call} ->
         # It's possible that Mox.Server is running on a remote node in the cluster. Since the
@@ -954,14 +957,17 @@ defmodule Mox do
   defp times(1), do: "once"
   defp times(n), do: "#{n} times"
 
-  defp format_process do
-    callers = caller_pids()
-
+  defp format_process(callers, report_dead_callers?) do
     "process #{inspect(self())}" <>
-      if Enum.empty?(callers) do
-        ""
-      else
-        " (or in its callers #{inspect(callers)})"
+      cond do
+        Enum.empty?(callers) ->
+          ""
+
+        report_dead_callers? and Enum.all?(callers, &(not Process.alive?(&1))) ->
+          " (or in its callers #{inspect(callers)}, all of which are dead)"
+
+        true ->
+          " (or in its callers #{inspect(callers)})"
       end
   end
 

test/mox_test.exs

@@ -294,12 +294,51 @@ defmodule MoxTest do
 
     test "raises if there is no expectation" do
       assert_raise Mox.UnexpectedCallError,
-                   ~r"no expectation defined for CalcMock\.add/2.*with args \[2, 3\]",
+                   ~r"no expectation found for CalcMock\.add/2.*with args \[2, 3\]",
                    fn ->
                      CalcMock.add(2, 3) == 5
                    end
     end
 
+    @tag :requires_caller_tracking
+    test "reports when all callers have died" do
+      parent = self()
+
+      {owner, owner_ref} =
+        spawn_monitor(fn ->
+          expect(CalcMock, :add, fn x, y -> x + y end)
+
+          Task.async(fn ->
+            send(parent, {:task_ready, self(), Process.get(:"$callers")})
+
+            receive do
+              :call_mock ->
+                error =
+                  try do
+                    CalcMock.add(1, 1)
+                  rescue
+                    error in Mox.UnexpectedCallError -> error
+                  end
+
+                send(parent, {:mock_error, error})
+            end
+          end)
+        end)
+
+      assert_receive {:task_ready, task, [^owner]}
+      assert_receive {:DOWN, ^owner_ref, :process, ^owner, :normal}
+
+      task_ref = Process.monitor(task)
+      send(task, :call_mock)
+
+      assert_receive {:mock_error, error}
+      assert_receive {:DOWN, ^task_ref, :process, ^task, :normal}
+
+      assert error.message ==
+               "no expectation found for CalcMock.add/2 in process #{inspect(task)} " <>
+                 "(or in its callers [#{inspect(owner)}], all of which are dead) with args [1, 1]"
+    end
+
     test "raises if all expectations are consumed" do
       expect(CalcMock, :add, fn x, y -> x + y end)
       assert CalcMock.add(2, 3) == 5