Why avoid mocks

Released MecksUnit v0.1.2 in which you can assert function calls with either called (returns a boolean) or assert_called (raises an error when not having found a match):

assert called List.wrap(:foo)
assert_called String.trim(_)

It works when running tests asynchronously (which produces child processes) if that’s what you mean. Could otherwise give an example of a different setup with multiple processes?

@archan937 does this also work with multiple processes?

You mean indirectly? Then the answer is yes. I have added the module Foo within the example which invokes String.trim() and the tests succeed

Does it work if String.trim is called outside that block?

Ok, cool. I’m very happy to know what you think about MecksUnit. And btw, I just pushed a new version in which defining mock modules are done far more elegantly

defmodule Foo do
  def trim(string) do
    String.trim(string)
  end
end

defmodule MecksUnitTest do
  use ExUnit.Case, async: true
  use MecksUnit.Case

  defmock String do
    def trim("  Paul  "), do: "Engel"
    def trim("  Foo  ", "!"), do: "Bar"
    def trim(_, "!"), do: {:passthrough, ["  Surprise!  !!!!", "!"]}
    def trim(_, _), do: :passthrough
  end

  defmock List do
    def wrap(:foo), do: [1, 2, 3, 4]
  end

  mocked_test "using mocked module functions" do
    task =
      Task.async(fn ->
        assert "Engel" == String.trim("  Paul  ")
        assert "Engel" == Foo.trim("  Paul  ")
        assert "Bar" == String.trim("  Foo  ", "!")
        assert "  Surprise!  " == String.trim("  Paul  ", "!")
        assert "MecksUnit" == String.trim("  MecksUnit  ")
        assert "Paul Engel" == String.trim("  Paul Engel  ", " ")
        assert [1, 2, 3, 4] == List.wrap(:foo)
        assert [] == List.wrap(nil)
        assert [:bar] == List.wrap(:bar)
        assert [:foo, :bar] == List.wrap([:foo, :bar])
      end)

    Task.await(task)
  end
end

Please note that you have to use defmock and mocked_test. Nice, huh?

That’s interesting, I’ll give it a try!

Rebinding is exactly what it is. Perhaps you meant it is not reassignment???

I would rather use GitHub - archan937/mecks_unit: A simple Elixir package to elegantly mock module functions within (asynchronous) ExUnit tests using Erlang's :meck library · GitHub … (async) mocking using the Erlang :meck library. I don’t want to compromis (by altering my initial code and making things interchangeable) because I just want to unit test my code.

There is a lot of information, could someone make a summary.
Thanks