Unit testing in clojure: mocking and lazy evaluation, atticus.mock and overloaded functions

As I am learning Clojure by practicing on the Google AI Challenge, I want to unit test all of my code. The clojure.test namespace contains useful macros and functions to define tests and express assertion but lacks mocking facilities. I need to count how many times the mocked function is called by the function under test. The atticus package serves this purpose, and I’ve been happy using it on the first few functions I made (e.g.).

Yet, I quickly faced a couple of issues due to my extreme noobitude. I will present them here along with the resulting noobish solutions with which I came up.

Atticus and overloaded functions

With atticus, how can one mock an overloaded function?
Well, it turns out that you can’t write

(atticus.mock/expects
   [(update-game-state [a b] (atticus.mock/times 3))
    (update-game-state [a b c d] (atticus.mock/times 2))]
   (call-tested-f))

A workaround is to write:

(atticus.mock/expects
   [(update-game-state [a b & rest] (atticus.mock/times 5))]
   (call-tested-f))

Testing and lazy evaluation

The mock (whether created by rebinding the mocked function var manually or with atticus) may prevent lazy sequences from being realized. Consider:

(defn mocked-f [n] (inc n))
(defn tested-f [v] (map mocked-f v))
(deftest tested-f-t
  (atticus.mock/expects
   [(mocked-f [n] (atticus.mock/times 3))]
   (tested-f [1 2 3])))

That test fails:

user> (tested-f-t)
 
FAIL in (tested-f-t) (mock.clj:27)
Expected 3 calls to mocked-f. 0 seen.
expected: (= actual expected)
  actual: (not (= 0 3))
nil

To solve that, you need to force the evaluation of the whole lazy sequence. I know this, but the revelation for me was that you can use doall at any level: it does not have to be directly applied to (in this case) the map function within the tested function (which would be highly inconvenient), but can be applied to the call to the tested function in the test. In retrospect, that makes sense, even without looking at the defintion of doall, as there is no reason to define it for each lazy seq generating function.

(deftest tested-f-t
  (atticus.mock/expects
   [(mocked-f [n] (atticus.mock/times 3))]
   (doall (tested-f [1 2 3]))))

I’d like to thank hugod and lpetit on #clojure for their advice and for reminding me about lazy evaluation.