Kata: Password validator in Clojure

I've just done the Password validator kata in Clojure.

It's a basic kata that, in my opinion, is very useful to think about how we choose the next test so that it helps us grow the code in small steps.

In this kata you have to validate a password.

The conditions that it has to fulfill to be valid are:

• It should have more than 6 characters
• It should contain at least one upper case character
• It should contain at least one lower case character
• It should contain at least one underscore
• It should contain at least one numeric character

These are my tests using Midje:

	(ns password-validator.core-test
	(:use midje.sweet)
	(:use [password-validator.core]))
	(facts
	"about password validator"
	(fact
	"it accepts a valid password"
	(valid? "_Ab3ccc") => true)
	(fact
	"it rejects passwords with no more than 6 characters"
	(valid? "_Ab3cc") => false)
	(fact
	"it rejects passwords that do not contain
	at least one upper case character"
	(valid? "_ab3ccc") => false)
	(fact
	"it rejects passwords that do not contain
	at least one lower case character"
	(valid? "_AB3CCC") => false)
	(fact
	"it rejects passwords that do not contain
	at least one underscore character"
	(valid? "aAB3CCC") => false)
	(fact
	"it rejects passwords that do not contain
	at least one numeric character"
	(valid? "_Abcccc") => false))

view raw password-validator-tests.clj hosted with ❤ by GitHub

and this is the final version of the code:

	(ns password-validator.core)
	(defn- has-more-than-6-chars? [password]
	(> (count password) 6))
	(defn- any? [pred coll]
	(not= nil (some pred coll)))
	(def ^:private contains-at-least-one-upper-case-char?
	(partial any? #(Character/isUpperCase %)))
	(def ^:private contains-at-least-one-lower-case-char?
	(partial any? #(Character/isLowerCase %)))
	(def ^:private contains-at-least-one-underscore-char?
	(partial any? #{\_}))
	(def ^:private contains-at-least-one-numeric-char?
	(partial any? #(Character/isDigit %)))
	(def ^:private conditions-to-be-valid
	[has-more-than-6-chars?
	contains-at-least-one-upper-case-char?
	contains-at-least-one-lower-case-char?
	contains-at-least-one-underscore-char?
	contains-at-least-one-numeric-char?])
	(defn valid? [password]
	(every? #(% password) conditions-to-be-valid))

view raw password-kata.clj hosted with ❤ by GitHub

I used a mix of TDD and work on the REPL to code it.

To document the process I commited the code after every passing test and every refactoring and also commited the REPL history.

You can find the commits step by step here and the code in this repository in GitHub.