Skip to content
/ mimex Public

Mimex provides a quick way to create mock doubles of Elixir modules

Notifications You must be signed in to change notification settings

joeellis/mimex

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 

History

5 Commits
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Repository files navigation

Mimex

Mimex is an Elixir library to help automate the creation and implementation of module doubles for testing. It's most useful when testing controllers in apps that use a service-oriented architecture as service often need to be mocked in order to fully test each possible code path.

Mimex aims to solve this by offering the these features:

  • Automate the creation of mock doubles. No need to keep separate files for mocks or constantly keep definition up to date, Mimex.stub(Foo) can read a given module and return back a module with the same functions / arities as the original.
  • Change the implementation of module functions on the fly at the test level. Keep everything needed for a test to run in the same place.

Installation

Simply install the package by adding mimex to your list of dependencies in mix.exs:

def deps do
  [{:mimex, "~> 0.1.0"}]
end

Usage

# config.exs
config :app, :user_service, UserService

# user_service.ex
defmodule UserService do
  def create_user(params) do
    # do things involved with creating a user
    ...

    {:ok, user}
  end
end


# user_controller.ex
defmodule UserController do
  @service Application.get_env(:app, :user_service)

  def create(params) do
    case @service.create_user(params) do
      {:ok, user} -> {:ok, user}
      {:error, reason} -> {:error, reason}
    end
  end
end


# test_helper.exs
ExUnit.start

# switch out our configured UserService with a Mimex double
Application.put_env(:app, :user_service, Mimex.stub(UserService))


# user_controller_test.exs
defmodule UserControllerTest do
  use ExUnit.Case

  import Mimex

  alias User
  alias UserService
  alias Mimex.UserService, as: FakeUserService

  setup do
    user = %User{id: 1}

    {:ok, user: user}
  end

  test "can create a user", {user: user} do
    # ensure our fake service returns the user we want when called
    expects FakeUserService, :create_user, fn (_params) -> {:ok, user} end

    {:ok, returned_user} = UserController.create(params)

    assert returned_user.id == user.id
  end

  test "can handle errors on user creation", {user: user} do
    # ensure that our fake service returns back an error
    expects FakeUserService, :create_user, fn (_params) -> {:error, "oh no it failed"} end

    {:error, reason} = UserController.create(params)

    assert reason == "oh no it failed"
  end
end

About

Mimex provides a quick way to create mock doubles of Elixir modules

Topics

Resources

Stars

Watchers

Forks

Releases

No releases published

Packages

No packages published

Languages