Suggestion: Provide an easier way to call the original function again

[PragTob]

First of all, thanks for mimic. I've been wanting to use it for a while, but convincing people to switch mocking libraries always proved hard. Finally have it in a project, and it's as easy and great as I expected it to be. I love mox and the idea, but sometimes the behavior definition etc. felt just like too much ceremony. Mimic strikes a great middle ground, thank you!

Anyhow, this feature request is probably best illustrated by the test I wanted to write. Essentially:

• mock email sending is failing, see job fails
• run job again, but this time succeeding and at best calling the original so I can assert the email was sent

Excerpt from test:

    Mimic.expect(Mailer, :deliver, fn _ -> {:error, "Mailer failed"} end)

    # we don't want it to exhaust retries
    drain_jobs(with_recursion: false)
    assert_no_email_sent()

    # Remove the mock/call original - sadly there is no direct way to do this
    Mimic.expect(Mailer, :deliver, fn args ->
      Mimic.call_original(Mailer, :deliver, [args])
    end)

    # Now drain jobs including scheduled/retryable ones
    drain_jobs(with_scheduled: true)

    assert_email_sent(fn email ->
      # ...
    end)

So, what I want to do is clearly and easily possible with:

    Mimic.expect(Mailer, :deliver, fn args ->
      Mimic.call_original(Mailer, :deliver, [args])
    end)

(or well stub)

The suggestion here is that, at least in my mind, this is common enough to warrant its own API but I may be wrong and admit that I'm testing a somewhat more special case where I only want to mock for one scenario/not all.

Something like Mimic.restore_original(mock) and or Mimic.restore_original(mock, function) would be a nice API imo. Of course, function name pending (I was thinking of remove_mock first, but it should also remove stubs and that's weird so restore_original seemed nice).

Anyhow, thanks for your consideration - feel free to say no as you'd be the one ending up having to maintain it (I might give implementing it a shot).

And again, thanks a lot for mimic!

[PragTob]

Have a bunny:

[edgurgel]

Hi @PragTob!

Thanks for writing such a detailed issued! I think it makes sense to support this use case. Let me get back to you next week or so! I will have time to consider the implications of a new public API, naming etc.

BTW thanks for benchee and the bunny! 🙇

[PragTob]

👋 @edgurgel yeah let me know, no promises cos time but if you have an API and mayve some guidance I might also take a stab at implementing but I've over-promised this too many times 😅

And pleasure! 😁

[edgurgel]

I'm trying to think of something that won't go against what we have today.

On verify_on_exit we check the remaining expectations. So "clearing" with Mimic.restore_original(mock, function) could be confusing if there were still expectations that were not fulfilled by that moment.

So at the moment I'm leaning on something that was proposed here as well #85

expect_and_call_original(MyMod, :my_fun, fn arg1, arg2, arg3 ->
  assert arg == ...
  :return_value_is_ignored!
end)

expect_and_call_original(&MyMod.my_fun/3)

And maybe a stub_and_call_original version of them?

Thoughts? 🤔

[PragTob]

🤔

I think having both of them sort of bloats the API interface a bit (by having the combination, having that for many functions seems somewhat bothersome).

My personal preference that restore_original would just raise if there are still unfilfilled expectations on any of the function being restored/changed. Now, if mimic has the means/data structures at that point I don't know - but I'd suspect so 😁

Again, just an opinion from a library user :)

[edgurgel]

Yeah! I think it's a good compromise that restore_original can only be called if all expectations were fulfilled and we clean up stubs and any fulfilled expectations (we don't allow calls to a function that had expectations that were fulfilled since 2.0.0 fee2662#diff-1620f6a40121b740d7d7e49fa381990fa433bee8aabb071fefeba9f5deababf8).

[PragTob]

Sounds great to me! 🚀