Add functionality to call the original function

README.md

@@ -115,7 +115,7 @@ Calculator
 verify!()
 ```
 
-Using `expect/4` on intra-module functions will not work, unless the function is referenced by it's fully qualified name. 
+Using `expect/4` on intra-module functions will not work, unless the function is referenced by it's fully qualified name.
 
 ```elixir
 defmodule Calculator do
@@ -206,7 +206,7 @@ To use DSL Mode `use Mimic.DSL` rather than `use Mimic` in your test.  DSL Mode
 ```
 
 ## Stubs with fake module
-`stub_with/2` enable substitute function call of a module with another similar module
+`stub_with/2` enable substitute function call of a module with another similar module.
 
 ```elixir
   defmodule BadCalculator do
@@ -222,6 +222,18 @@ To use DSL Mode `use Mimic.DSL` rather than `use Mimic` in your test.  DSL Mode
   end
 ```
 
+## Calling the original
+`call_original/3` allows to call original unmocked version of the function.
+
+```elixir
+setup :set_mimic_private
+
+test "calls original function even if it has been is stubbed" do
+  stub_with(Calculator, InverseCalculator)
+
+  assert call_original(Calculator, :add, [1, 2]) == 3
+end
+```
 
 ## Implementation Details & Performance
 

lib/mimic.ex

@@ -374,6 +374,38 @@ defmodule Mimic do
     end
   end
 
+  @doc """
+  Call original implementation of a function.
+
+  This function allows you to call the original implementation of a function,
+  even if it has been stubbed, rejected or expected.
+
+  ## Arguments:
+
+    * `module` - the name of the module in which we're calling.
+    * `function_name` - the name of the function we're calling.
+    * `args` - the arguments of the function we're calling.
+
+  ## Raises:
+
+    * If `function_name` does not exist in `module`.
+
+  ## Example:
+
+      iex> Mimic.call_original(Calculator, :add, [1, 2])
+      3
+
+  """
+  @spec call_original(module, atom, list) :: any
+  def call_original(module, function_name, args) do
+    arity = length(args)
+
+    raise_if_not_exported_function!(module, function_name, arity)
+    func = Function.capture(Mimic.Module.original(module), function_name, arity)
+
+    Kernel.apply(func, args)
+  end
+
   @doc """
   Verifies the current process after it exits.
 

test/mimic_test.exs

@@ -924,7 +924,7 @@ defmodule Mimic.Test do
     end
   end
 
-  describe "copy/1 with duplicates does nothing" do
+  describe "copy/1 with duplicates" do
     setup :set_mimic_private
 
     test "stubs still stub" do
@@ -946,6 +946,44 @@ defmodule Mimic.Test do
     end
   end
 
+  describe "call_original/3" do
+    setup :set_mimic_private
+
+    test "calls original function even if it has been is stubbed" do
+      stub_with(Calculator, InverseCalculator)
+
+      assert call_original(Calculator, :add, [1, 2]) == 3
+    end
+
+    test "calls original function even if it has been rejected as a module function" do
+      Mimic.reject(Calculator, :add, 2)
+
+      assert call_original(Calculator, :add, [1, 2]) == 3
+    end
+
+    test "calls original function even if it has been rejected as a capture" do
+      Mimic.reject(&Calculator.add/2)
+
+      assert call_original(Calculator, :add, [1, 2]) == 3
+    end
+
+    test "when called on a function that has not been stubbed" do
+      assert call_original(Calculator, :add, [1, 2]) == 3
+    end
+
+    test "when called on a module that does not exist" do
+      assert_raise ArgumentError, "Function add/2 not defined for NonExistentModule", fn ->
+        call_original(NonExistentModule, :add, [1, 2])
+      end
+    end
+
+    test "when called on a function that does not exist" do
+      assert_raise ArgumentError, "Function non_existent_call/2 not defined for Calculator", fn ->
+        call_original(Calculator, :non_existent_call, [1, 2])
+      end
+    end
+  end
+
   describe "structs" do
     setup :set_mimic_private