expectations.clojure.test — expectations/clojure-test 1.1.0

This namespace provides compatibility with clojure.test and related tooling.

This namespace should be used standalone, without requiring the 'expectations' namespace -- this provides a translation layer from Expectations syntax down to clojure.test functionality.

We do not support ClojureScript in clojure.test mode, sorry.

? clj macro

(? form)

Wrapper for forms that might throw an exception so exception class names can be used as predicates. This is only needed for more-> so that you can thread exceptions into code that can parse information out of them, to be used with various expect predicates.

all-report clj

(all-report store)

Given an atom in which to accumulate results, return a function that can be used in place of clojure.test/do-report, which simply remembers all the reported results.

This is used to support the semantics of expect/in.

approximately clj

(approximately v)

(approximately v d)

Given a value and an optional delta (default 0.001), return a predicate that expects its argument to be within that delta of the given value.

defexpect clj macro

(defexpect n & body)

Given a name (a symbol that may include metadata) and a test body, produce a standard 'clojure.test' test var (using 'deftest').

(defexpect name expected actual) is a special case shorthand for (defexpect name (expect expected actual)) provided as an easy way to migrate legacy Expectation tests to the 'clojure.test' compatibility version.

expect clj macro

(expect a)

(expect e a)

(expect e a ex?)

(expect e a ex? e')

Translate Expectations DSL to clojure.test language.

expecting clj macro

(expecting string & body)

The Expectations version of clojure.test/testing.

from-each clj macro

(from-each & _)

functionally clj

(functionally expected-fn actual-fn)

(functionally expected-fn actual-fn difference-fn)

Given a pair of functions, return a custom predicate that checks that they return the same result when applied to a value. May optionally accept a 'difference' function that should accept the result of each function and return a string explaininhg how they actually differ. For explaining strings, you could use expectations/strings-difference. (only when I port it across!)

Right now this produces pretty awful failure messages. FIXME!

humane-test-output? clj

If Humane Test Output is available, activate it, and enable compatibility of our =? with it.

in clj macro

(in & _)

more clj macro

(more & _)

more-> clj macro

(more-> & _)

more-of clj macro

(more-of & _)

side-effects clj macro

(side-effects fn-vec & forms)

spec? clj

(spec? e)