doodloo
Mocking during one test or one test module only
Consider the following scenario:
- A
Normalizerbehaviour with anormalize_emailfunction. - A User module, with a
changesetfunction that should normalize theemailparam. - The
User.changesetfunction calls a default implementation defined such asnormalizer().normalize_email()-normalizer()is defined to returnApplication.get_env(:my_app :normalizer, Utils). It means that by default there’s anormalize_emailfunction in theUtilsmodule that does the job. - Note that many other functions in the
Usermodule use thenormalizer().normalize_email()function. - In a
mocks.exfile in thetest/supportfolder, weMox.defmock(NormalizerMock, for: Normalizer)and intest_helper.exswe simplyApplication.put_env(:my_app :normalizer, NormalizerMock).
Now in our user tests, this is all nice and dandy - we can expect on the mock and make sure that the correct function is called by all the User functions such as the User.changeset one.
The intent is really just to test that the User.changeset and other functions delegate the work to the Utils module - so mocking it gives us a way to verify this. We are not interested in what the Utils.normalize_email function does from these tests and the only place where the Utils.normalize_email function is tested is in its own Utils tests. In other words we just check that the NormalizerMock.normalize_email function was called exactly once with a parameter we control, and that the result of the User.changeset function includes this controlled parameter in its return.
However in other tests that target other files and modules, we would like this mock to be absent completely, and have the User.changeset function normally call onto the Utils.normalize_email function.
For example, in tests related to a registration controller (or say more integration tests), we call functions on a Registration module, itself calling the User.changeset function - and in this case we don’t care to have User.changeset call a mock - instead it should call its default implementation.
Of course, doing things pixel-perfect would require us to actually mock the User.changeset function in the Registration tests, but there is too much overhead here.
Is there a way to have mocks applied only to one test? To one test file? Where would all the moving pieces go (Eg where would the defmock call be, the Application.put_env call etc)?
EDIT: Basically a solution we found is to include stub(NormalizerMock, Utils) in every single other test - which is definitely not acceptable. What we’re trying to understand is how we could do the opposite - have Utils be the default implementation during all tests, except for a few in which we want to mock and expect that it’s being called. Does this make sense? Would it for example be OK to have a macro run before each test suite and bake a setup block for each test calling stub_with NormalizerMock, Utils so tests that don’t use the mock don’t have it, while tests that use the mock could still perform NormalizerMock.expect tests?
Most Liked
doodloo
Replying to myself - something we found would work is the following.
Create a Case base module that all test modules will use instead of ExUnit.Case:
defmodule MyApp.Case do
use ExUnit.CaseTemplate
import Hammox, only: [stub_with: 2]
setup _tags do
NormalizerMock |> stub_with(Utils)
:ok
end
end
If you also have a DataCase or other helpers, don’t forget to have them use this new TestCase module too!
Then in all our test modules, we simply use MyApp.Case, so it sets default implementations instead of mocks. For example:
defmodule MyApp.Accounts.UserTest do
# Note that his internally `use`s the `MyApp.Case` described earlier, but if our test isn't
# a `DataCase` we would just `use MyApp.Case` instead.
use MyApp.DataCase, async: true
import Hammox, only: [expect: 3, verify_on_exit!: 1]
doctest User, import: true
setup :verify_on_exit!
describe "changeset/2" do
test "normalizes the email" do
new_email = Faker.Internet.email()
exp = "normalized_#{new_email}"
# Note that since we called `setup :verify_on_exit!`, every `expect` will be verified, including
# the this one:
NormalizerMock
|> expect(:normalize_email, fn ^new_email -> exp end)
%{changes: changes} =
:user
|> build
|> User.changeset(%{email: new_email})
assert changes == %{email: exp}
end
end
end
Popular in Questions
Other popular topics
Latest on Elixir Forum
Sponsor Spotlight
The deployment platform built for Elixir: PaaS ease, VPS control.
Categories:
Sub Categories:
Forums
Our Sponsors
Build Elixir applications with speed and confidence.
Supporting innovation across the BEAM ecosystem.
We build reliable cloud platforms for business-critical systems.
Catch errors, track performance, monitor hosts and more.
Real-time error tracking, performance insights, and observability for devs.
Practical resources that improve the lives of professional developers.
Develop your skills with books, videos, and courses.
Enabling companies to succeed by building software people love.
Courses that'll move you from confusion to "Aha, now I get it!"