Skip to content
Simple injectable test dependencies for Elixir
Elixir Shell
Branch: master
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Type Name Latest commit message Commit time
Failed to load latest commit information.
config Initial commit Jan 10, 2017
.gitignore Initial commit Jan 10, 2017
mix.exs Add failing tests for stub syntax Apr 22, 2019


Double builds on-the-fly injectable dependencies for your tests. It does NOT override behavior of existing modules or functions. Double uses Elixir's built-in language features such as pattern matching and message passing to give you everything you would normally need a complex mocking tool for.


The package can be installed as:

  1. Add double to your list of dependencies in mix.exs:
def deps do
  [{:double, "~> 0.7.0", only: :test}]


Start Double in your test/test_helper.exs file:


Module/Behaviour Doubles

Double creates a fake module based off of a behaviour or module. You can use this module like any other module that you call functions on. Each stub you define will verify that the function name and arity are defined in the target module or behaviour.

defmodule Example do
  def process(io \\ IO) do # allow an alternative dependency to be passed
    io.puts("It works without mocking libraries!")

defmodule ExampleTest do
  use ExUnit.Case
  import Double

  test "example outputs to console" do
    io_stub = stub(IO,:puts, fn(_msg) -> :ok end)

    Example.process(io_stub) # inject the stub module

    # use built-in ExUnit assert_receive/refute_receive to verify things
    assert_receive({IO, :puts, ["It works without mocking libraries!"]})



# Stub a function
dbl = stub(ExampleModule, :add, fn(x, y) -> x + y end)
dbl.add(2, 2) # 4

# Pattern match arguments
dbl = stub(Application, :ensure_all_started, fn(:logger) -> nil end)
dbl.ensure_all_started(:logger) # nil
dbl.ensure_all_started(:something) # raises FunctionClauseError

# Stub as many functions as you want
dbl = ExampleModule
|> stub(:add, fn(x, y) -> x + y end)
|> stub(:subtract, fn(x, y) -> x - y end)

Different return values for different arguments

dbl = ExampleModule
|> stub(:example, fn("one") -> 1 end)
|> stub(:example, fn("two") -> 2 end)
|> stub(:example, fn("three") -> 3 end)

dbl.example("one") # 1
dbl.example("two") # 2
dbl.example("three") # 3

Multiple calls returning different values

dbl = ExampleModule
|> stub(:example, fn("count") -> 1 end)
|> stub(:example, fn("count") -> 2 end)

dbl.example("count") # 1
dbl.example("count") # 2
dbl.example("count") # 2


dbl = ExampleModule
|> stub(:example_with_error_type, fn -> raise RuntimeError, "kaboom!" end)
|> stub(:example_with_error_type, fn -> raise "kaboom!" end)

Verifying calls

If you want to verify that a particular stubbed function was actually executed, Double ensures that a message is receivable to your test process so you can just use the built-in ExUnit assert_receive/assert_received. The message is a 3-tuple {module, :function, [arg1, arg2]}and .

dbl = ExampleModule
|> stub(:example, fn("count") -> 1 end)
assert_receive({ExampleModule, :example, ["count"]})

Remember that pattern matching is your friend so you can do all kinds of neat tricks on these messages.

assert_receive({ExampleModule, :example, ["c" <> _rest]}) # verify starts with "c"
assert_receive({ExampleModule, :example, [%{test: 1}]) # pattern match map arguments
assert_receive({ExampleModule, :example, [x]}) # assign an argument to x to verify another way
assert x == "count"

Module Verification

By default your setups will check the source module to ensure the function exists with the correct arity.

stub(IO, :non_existent_function, fn(x) -> x end) # raises VerifyingDoubleError

Clearing Stubs

Occasionally it's useful to clear the stubs for an existing double. This is useful when you have a shared setup and a test needs to change the way a double is stubbed without recreating the whole thing.

dbl = IO
|> stub(:puts, fn(_) -> :ok end)
|> stub(:inspect, fn(_) -> :ok end)

# later
dbl |> clear(:puts) # clear an individual function
dbl |> clear([:puts, :inspect]) # clear a list of functions
dbl |> clear() # clear all functions
You can’t perform that action at this time.