@spec allow(module(), pid(), pid()) :: module() | {:error, atom()}

Allow other processes to share expectations and stubs defined by another process.

Arguments:

• module - the copied module.
• owner_pid - the process ID of the process which created the stub.
• allowed_pid - the process ID of the process which should also be allowed to use this stub.

Raises:

• If Mimic is running in global mode.

Allows other processes to share expectations and stubs defined by another process.

Example

test "invokes add from a task" do
  Calculator
  |> expect(:add, fn x, y -> x + y end)

  parent_pid = self()

  Task.async(fn ->
    Calculator |> allow(parent_pid, self())
    assert Calculator.add(2, 3) == 5
  end)
  |> Task.await
endcopy

@spec call_original(module(), atom(), list()) :: any()

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])
3copy

@spec copy(
  module(),
  keyword()
) :: :ok | no_return()

Prepare module for mocking.

Ideally, don't call this function twice for the same module, but in case you do, this function is idempotent. It will not delete any stubs or expects that you've set up.

Arguments:

• module - the name of the module to copy.
• opts - Extra options

Options:

• type_check - Must be a boolean defaulting to false. If true the arguments and return value are validated against the module typespecs or the callback typespecs in case of a behaviour implementation.

@spec expect(atom(), atom(), non_neg_integer(), function()) :: module()

Define a stub which must be called within an example.

This function is almost identical to stub/3 except that the replacement function must be called within the lifetime of the calling pid (i.e. the test example).

Arguments:

• module - the name of the module in which we're adding the stub.
• function_name - the name of the function we're stubbing.
• function - the function to use as a replacement.

Raises:

• If module is not copied.
• If function_name is not publicly exported from module with the same arity.
• If function is not called by the stubbing process.

Example

iex> Calculator.add(2, 4)
6

iex> Mimic.expect(Calculator, :add, fn x, y -> x * y end)
...> Calculator.add(2, 4)
8copy

@spec mode() :: :private | :global

Returns the current mode (:global or :private)

@spec reject(function()) :: module()

Define a stub which must not be called.

This function allows you do define a stub which must not be called during the course of this test. If it is called then the verification step will raise.

Arguments:

• function - A capture of the function which must not be called.

Raises:

• If function is not called by the stubbing process while calling verify!/1.

Example:

iex> Mimic.reject(&Calculator.add/2)
Calculatorcopy

@spec reject(module(), atom(), non_neg_integer()) :: module()

Define a stub which must not be called.

This function allows you do define a stub which must not be called during the course of this test. If it is called then the verification step will raise.

Arguments:

• module - the name of the module in which we're adding the stub.
• function_name - the name of the function we're stubbing.
• arity - the arity of the function we're stubbing.

Raises:

• If function is not called by the stubbing process while calling verify!/1.

Example:

iex> Mimic.reject(Calculator, :add, 2)
Calculatorcopy

@spec set_mimic_from_context(map()) :: :ok

Chooses the mode based on ExUnit context. If async is true then the mode is private, otherwise global.

setup :set_mimic_from_contextcopy

@spec set_mimic_global(map()) :: :ok

Sets the mode to global. Mocks can be set and used by all processes

setup :set_mimic_globalcopy

@spec set_mimic_private(map()) :: :ok

Sets the mode to private. Mocks can be set and used by the process

setup :set_mimic_privatecopy

@spec stub(module()) :: module()

Replace all public functions in module with stubs.

The stubbed functions will raise if they are called.

Arguments:

• module - The name of the module to stub.

Raises:

• If module is not copied.
• If function is not called by the stubbing process.

Example

iex> Mimic.stub(Calculator)
...> Calculator.add(2, 4)
** (ArgumentError) Module Calculator has not been copied. See docs for Mimic.copy/1copy

@spec stub(module(), atom(), function()) :: module()

Define a stub function for a copied module.

Arguments:

• module - the name of the module in which we're adding the stub.
• function_name - the name of the function we're stubbing.
• function - the function to use as a replacement.

Raises:

• If module is not copied.
• If function_name is not publicly exported from module with the same arity.

Example

iex> Calculator.add(2, 4)
6

iex> Mimic.stub(Calculator, :add, fn x, y -> x * y end)
...> Calculator.add(2, 4)
8copy

@spec stub_with(module(), module()) :: module()

Replace all public functions in module with public function in mocking_module.

If there's any public function in module that are not in mocking_module, it will raise if it's called

Arguments:

• module - The name of the module to stub.
• mocking_module - The name of the mocking module to stub the original module.

Raises:

• If module is not copied.
• If function is not called by the stubbing process.

Example

defmodule InverseCalculator do
  def add(a, b), do: a - b
end

iex> Mimic.stub_with(Calculator, InverseCalculator)
...> Calculator.add(2, 4)
...> -2copy

@spec verify!(pid()) :: :ok

Verify if expectations were fulfilled for a process pid

@spec verify_on_exit!(map()) :: :ok | no_return()

Verifies the current process after it exits.

If you want to verify expectations for all tests, you can use verify_on_exit!/1 as a setup callback:

setup :verify_on_exit!copy