Kata: Ohce in Clojure using outside-in TDD with Midje

I did the Ohce kata in Clojure using outside-in TDD with Midje.

I started by writing a nearly end-to-end test for the scenario of running ohce during the morning:

	(ns ohce.acceptance-test
	(:require [midje.sweet :refer :all]
	[ohce.core :refer :all]))
	(unfinished hour-fn)
	(unfinished read-input)
	(future-facts
	"about running ohce"
	(fact
	"during the morning"
	(clojure.string/split
	(with-out-str
	(ohce hour-fn read-input "Pedro"))
	#"\n") => ["¡Buenos días Pedro!"
	"aloh"
	"oto"
	"¡Bonita palabra!"
	"pots"
	"Adios Pedro"]
	(provided
	(hour-fn) => 8
	(read-input) =streams=> ["hola" "oto" "stop" "Stop!"])))

view raw initial_acceptance_test.clj hosted with ❤ by GitHub

In this test I used Midje's unfinished and provided macros to stub the hour-fn and read-input functions and with-out-str to capture the any printed lines.

Using Midje's future-facts macro I avoided seeing this acceptance test failing every time the tests were run, instead I saw a reminder message like this one:

	$ lein midje
	WORK TO DO "about running ohce" at (acceptance_test.clj:8)

view raw future_fact_remainder.sh hosted with ❤ by GitHub

Next I started testing ohce at the unit level. These are the resulting facts:

	(ns ohce.unit-tests.ohce-test
	(:require
	[midje.sweet :refer :all]
	[ohce.ohce :refer :all]
	[ohce.test-helpers :as helpers]))
	(unfinished select-greeting)
	(unfinished read-input)
	(facts
	"about ohce"
	(fact
	"it greets the user"
	(let [notifier (helpers/fake-notifier)
	stop-word "Stop!"]
	(ohce select-greeting notifier read-input stop-word ...username...) => irrelevant
	(provided
	(read-input) => "Stop!"
	(select-greeting ...username...) => ...greeting...)
	(helpers/args-of-call
	:greet :notifications notifier) => [[...greeting...]]))
	(fact
	"it reverses the user inputs"
	(let [notifier (helpers/fake-notifier)
	stop-word "Stop!"]
	(ohce select-greeting notifier read-input stop-word ...username...) => irrelevant
	(provided
	(select-greeting ...username...) => irrelevant
	(read-input) =streams=> ["hola" "lolo" "Stop!"])
	(helpers/args-of-call
	:echo :notifications notifier) => [["aloh"] ["olol"]]))
	(fact
	"it ignores inputs that are blank"
	(let [notifier (helpers/fake-notifier)
	stop-word "Stop!"]
	(ohce select-greeting notifier read-input stop-word ...username...) => irrelevant
	(provided
	(select-greeting ...username...) => irrelevant
	(read-input) =streams=> ["memo" "" "moko" "Stop!"])
	(helpers/args-of-call
	:echo :notifications notifier) => [["omem"] ["okom"]]))
	(fact
	"it identifies palindromes"
	(let [notifier (helpers/fake-notifier)
	stop-word "Stop!"]
	(ohce select-greeting notifier read-input stop-word ...username...) => irrelevant
	(provided
	(select-greeting ...username...) => irrelevant
	(read-input) =streams=> ["oto" "ana" "Stop!"])
	(helpers/args-of-call
	:echo :notifications notifier) => [["oto"] ["ana"]]
	(helpers/args-of-call
	:palindromes-rock :notifications notifier) => [:no-args :no-args]))
	(fact
	"it knows when to stop"
	(let [notifier (helpers/fake-notifier)
	stop-word "Stop!"]
	(ohce select-greeting notifier read-input stop-word ...username...) => irrelevant
	(provided
	(select-greeting ...username...) => irrelevant
	(read-input) =streams=> ["Stop!"])
	(helpers/args-of-call
	:bye-user :notifications notifier) => [[...username...]])))

view raw ohce_test.clj hosted with ❤ by GitHub

For these facts I used a fake implementation of the Notifier protocol:

	(defprotocol Notifier
	(greet [this greeting])
	(echo [this reversed-phrase])
	(palindromes-rock [this])
	(bye-user [this name]))

view raw notifier-protocol.clj hosted with ❤ by GitHub

which captured the arguments with which the functions of the protocol implementation were being called:

	(ns ohce.test-helpers
	(:require
	[ohce.notifications :as notifications]))
	(defn- register-call [func-keyword an-atom & args]
	(let [args (if (nil? args) :no-args args)
	calls (vec (func-keyword @an-atom))]
	(swap! an-atom assoc func-keyword (conj calls args))))
	(defn args-of-call
	[func-keyword atom-keyword protocol-implementation]
	(func-keyword @(atom-keyword protocol-implementation)))
	(defrecord FakeNotifier [notifications]
	notifications/Notifier
	(greet [_ greeting]
	(register-call :greet notifications greeting))
	(echo [_ reversed-phrase]
	(register-call :echo notifications reversed-phrase))
	(palindromes-rock [_]
	(register-call :palindromes-rock notifications))
	(bye-user [_ name]
	(register-call :bye-user notifications name)))
	(defn fake-notifier []
	(->FakeNotifier (atom {})))
	(defn output-lines [f & args]
	(clojure.string/split (with-out-str (apply f args)) #"\n"))

view raw test_helpers.clj hosted with ❤ by GitHub

I could have used Midje's defrecord-openly and provided macros instead but I didn't like having to use defrecord-openly in production code.

Update:
The statement above is wrong. It is not necessary at all to use defrecord-openly in your production code in order to mock a protocol. See how it's done in this other post: Revisited Kata: Using Midje's defrecord-openly to mock a protocol in Ohce.
--------------------------

Another thing to notice in that test is the use of Midje's metaconstants to avoid the facts knowing about the "shape" of data (where it was possible to do it).

Well, those facts lead to the following code:

	(ns ohce.ohce
	(:require
	[ohce.notifications :as notifications]))
	(defn- reverse-str [input]
	(apply str (reverse input)))
	(defn- palindrome? [input]
	(= input (reverse-str input)))
	(defn- should-stop? [input stop-word]
	(= input stop-word))
	(defn- respond-to-input [notifier input]
	(notifications/echo notifier (reverse-str input))
	(when (palindrome? input)
	(notifications/palindromes-rock notifier)))
	(defn- process-input [notifier input]
	(when-not (clojure.string/blank? input)
	(respond-to-input notifier input)))
	(defn- interact-with-user [notifier read-input stop-word]
	(loop [input (read-input)]
	(when-not (should-stop? input stop-word)
	(do (process-input notifier input)
	(recur (read-input))))))
	(defn ohce [select-greeting notifier read-input stop-word name]
	(notifications/greet notifier (select-greeting name))
	(interact-with-user notifier read-input stop-word)
	(notifications/bye-user notifier name))

view raw ohce.clj hosted with ❤ by GitHub

Then I started applying TDD on the next level to write ConsoleNotifier, an implementation of the Notifier protocol:

	(ns ohce.unit-tests.console-notifications-test
	(:require
	[midje.sweet :refer :all]
	[ohce.test-helpers :as test-helpers]
	[ohce.notifications :refer :all]))
	(facts
	"about console notifications"
	(let [notifier (console-notifier {:bye-word "Adios"
	:celebration "¡Bonita palabra!"})]
	(fact
	"greeting user"
	(test-helpers/output-lines
	greet notifier "greeting") => ["greeting"])
	(fact
	"greeting user"
	(test-helpers/output-lines
	bye-user notifier "Juan") => ["Adios Juan"])
	(fact
	"echoing word"
	(test-helpers/output-lines
	echo notifier "moko") => ["moko"])
	(fact
	"celebrating palindromes"
	(test-helpers/output-lines
	palindromes-rock notifier) => ["¡Bonita palabra!"])))

view raw console_notifications_test.clj hosted with ❤ by GitHub

and the select-greeting function (select-by-day-period in this case):

	(ns ohce.unit-tests.day-period-greeting-selection-test
	(:require
	[midje.sweet :refer :all]
	[ohce.greet-selectors :refer [select-by-day-period]]))
	(unfinished hour-fn)
	(facts
	"about hour greeter"
	(fact
	"during the morning"
	(select-by-day-period hour-fn "Koko") => "¡Buenos días Koko!"
	(provided (hour-fn) => 6)
	(select-by-day-period hour-fn "Koko") => "¡Buenos días Koko!"
	(provided (hour-fn) => 8)
	(select-by-day-period hour-fn "Koko") => "¡Buenos días Koko!"
	(provided (hour-fn) => 11))
	(fact
	"during the afternoon"
	(select-by-day-period hour-fn "Koko") => "¡Buenas tardes Koko!"
	(provided (hour-fn) => 12)
	(select-by-day-period hour-fn "Koko") => "¡Buenas tardes Koko!"
	(provided (hour-fn) => 16)
	(select-by-day-period hour-fn "Koko") => "¡Buenas tardes Koko!"
	(provided (hour-fn) => 19))
	(fact
	"during the afternoon"
	(select-by-day-period hour-fn "Koko") => "¡Buenas noches Koko!"
	(provided (hour-fn) => 20)
	(select-by-day-period hour-fn "Koko") => "¡Buenas noches Koko!"
	(provided (hour-fn) => 24)
	(select-by-day-period hour-fn "Koko") => "¡Buenas noches Koko!"
	(provided (hour-fn) => 5)))

view raw day_period_greeter_test.clj hosted with ❤ by GitHub

Once those tests were passing, I just had to inject a ConsoleNotifier record and the select-greeting function into ohce to make the acceptance test pass:

	(ns ohce.acceptance-test
	(:require
	[midje.sweet :refer :all]
	[ohce.ohce :refer :all]
	[ohce.greet-selectors :refer [select-by-day-period]]
	[ohce.notifications :refer [console-notifier]]
	[ohce.test-helpers :as helpers]))
	(unfinished read-input)
	(unfinished hour-fn)
	(let [notifications-config {:bye-word "Adios"
	:celebration "¡Bonita palabra!"}]
	(facts
	"about running ohce"
	(fact
	"during the morning"
	(let [stop-word "Stop!"
	any-hour-during-morning 9
	notifier (console-notifier notifications-config)
	select-greeting (fn [name] (select-by-day-period hour-fn name))
	ohce (partial ohce select-greeting notifier #(read-input) stop-word)]
	(helpers/output-lines
	ohce "Pedro") => ["¡Buenos días Pedro!"
	"aloh"
	"oto"
	"¡Bonita palabra!"
	"pots"
	"Adios Pedro"]
	(provided
	(hour-fn) => any-hour-during-morning
	(read-input) =streams=> ["hola" "oto" "stop" "Stop!"])))
	(fact
	"during the afternoon"
	(let [stop-word "Stop!"
	any-hour-during-afternoon 16
	notifier (console-notifier notifications-config)
	select-greeting (fn [name] (select-by-day-period hour-fn name))
	ohce (partial ohce select-greeting notifier #(read-input) stop-word)]
	(helpers/output-lines
	ohce "Lolo") => ["¡Buenas tardes Lolo!"
	"opip"
	"Adios Lolo"]
	(provided
	(hour-fn) => any-hour-during-afternoon
	(read-input) =streams=> ["pipo" "Stop!"])))
	(fact
	"during the afternoon"
	(let [stop-word "Stop!"
	any-hour-during-night 1
	notifier (console-notifier notifications-config)
	select-greeting (fn [name] (select-by-day-period hour-fn name))
	ohce (partial ohce select-greeting notifier #(read-input) stop-word)]
	(helpers/output-lines
	ohce "Juan") => ["¡Buenas noches Juan!"
	"oko"
	"¡Bonita palabra!"
	"Adios Juan"]
	(provided
	(hour-fn) => any-hour-during-night
	(read-input) =streams=> ["oko" "Stop!"])))))

view raw acceptance_test.clj hosted with ❤ by GitHub

I also added two other scenarios (running ohce during the afternoon and during the night).

A curious thing to notice is that I couldn't use partial with select-greeting if I wanted the provided macro to work with hour-fn, that's why I used a lambda instead. Due to the same problem I also had to wrap the read-input function inside a lambda.

Then to be able to really run ohce on the console I just had to write a real hour-fn function (tested on the REPL):

	(ns ohce.clock
	(:import (java.util Calendar)))
	(defn hour []
	(.get (Calendar/getInstance) Calendar/HOUR_OF_DAY))

view raw clock.clj hosted with ❤ by GitHub

and create a -main function (read-input is just the Clojure's read-line function):

	(ns ohce.core
	(:require
	[ohce.ohce :refer :all]
	[ohce.clock :as clock]
	[ohce.notifications :refer [console-notifier]]
	[ohce.greet-selectors :as greet-selectors]))
	(defn -main [& args]
	(let [select-greeting (partial greet-selectors/select-by-day-period clock/hour)
	notifier (console-notifier {:bye-word "Adios"
	:celebration "¡Bonita palabra!"})
	ohce (partial ohce select-greeting notifier read-line "Stop!")]
	(ohce (first args))))

view raw ohce-core.clj hosted with ❤ by GitHub

This is an example of running ohce:

	$ lein run Lolo
	¡Buenas tardes Lolo!
	hola
	aloh
	vino
	oniv
	akka
	akka
	¡Bonita palabra!
	Stop!
	Adios Lolo
	$

view raw running_ohce hosted with ❤ by GitHub

I committed after each passing test and each tiny refactoring, so that you can follow the process if you feel like. You can check the commits step by step here.

You can find the resulting code in this GitHub repository.

Doing this kata helped me to learn a lot of new things about Midje.