This is a followup to my earlier attempt here
The difference I am experimenting with here is to see if swapping out entire modules rather than individual functions is less intrusive on the code under test.
The problem of separating determinism from nondeterminism has been solved for decades with dependency injection,
and until someone is able to point out a better way,
I am sticking with the theory of dependency injection for now.
The idea is to pass modules into the parameter list in production,
and make stubs and fakes look like modules for test.
This turned out to be much more difficult than I expected, but I am not sure if that is because it is not easy in Elixir, or if I am not aware of the proper language constructs.
I ended up dynamically naming my fake and stub modules to keep their state isolated from each other.
I refactored duplication with a macro.
I pasted the IOFake module to the end of test/test_helper.exs because I couldn’t figure out another way to get the other tests to see it.
Although I would prefer a solution that is more simple and less clever,
this does still seem, to me, to be an objectively superior way to test non-determinism in Elixir code than what I have seen so far in the ecosystem.
I can run my tests in parallel without worrying about colliding state.
I have taken complete control of all non-determinism.
The code under test does not need to change much (I could even leave the parameters capitalized, making them look like modules instead of parameters).
I don’t have to make excuses regarding why this or that is too hard to test, I just test everything.
I only did IO.puts here, but you can see how this can be extended to any non-determinism.
For those of you that are interested in this kind of thing, do you see any flaws in my logic?
Or perhaps I missed a better way because I don’t know elixir that well yet?
defmodule ConcurrentA do
def send_line(line, io) do
io.puts(line)
end
end
defmodule ConcurrentB do
def send_line(line, io) do
io.puts(line)
end
end
defmodule ConcurrentATest do
use ExUnit.Case, async: true
test "send line" do
Fake.with_io fn io ->
ConcurrentA.send_line("hello", io)
ConcurrentA.send_line("world", io)
actual = io.get_lines()
expected = ["hello", "world"]
assert expected == actual
end
end
end
defmodule ConcurrentBTest do
use ExUnit.Case, async: true
test "send line" do
Fake.with_io fn io ->
ConcurrentB.send_line("hello", io)
ConcurrentB.send_line("world", io)
actual = io.get_lines()
expected = ["hello", "world"]
assert expected == actual
end
end
end
# Pasted at the end of test_helper.exs
defmodule IOFake do
defmacro __using__(_) do
quote do
def loop(lines) do
receive do
{:get_lines, caller} ->
send(caller, Enum.reverse(lines))
loop(lines)
{:puts, line} ->
new_lines = [line | lines]
loop(new_lines)
{:stop, caller} ->
IO.puts("stopped #{__MODULE__}")
send(caller, :stopped)
x -> raise "unmatched pattern #{inspect x}"
end
end
def puts(line) do
send(__MODULE__, {:puts, line})
end
def get_lines() do
send(__MODULE__, {:get_lines, self()})
receive do x -> x end
end
def start() do
process = spawn_link(fn -> __MODULE__.loop([]) end)
Process.register(process, __MODULE__)
IO.puts("started #{__MODULE__}")
end
def stop() do
send(__MODULE__, {:stop, self()})
receive do x -> x end
end
end
end
end
defmodule Fake do
def with_io(f) do
id = System.unique_integer([:positive])
{_, io, _, _} = defmodule String.to_atom("IOFake#{id}") do
use IOFake
end
io.start()
result = f.(io)
io.stop()
result
end
end
