expectations.clojure.test — expectations 2.2.0-rc3

This namespace provides compatibility with clojure.test and related tooling. This namespace can be used standalone, without requiring the 'expectations' namespace -- all functionality from that namespace is exposed via this one.

When this namespace is loaded, the 'run on shutdown' hook is automatically disabled -- tests are named functions that get run explicitly instead.

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

*prune-stacktrace* clj

*report-counters* clj

*test-meta* clj

*test-name* clj

*test-var* clj

->failure-message clj

(->failure-message {:keys [raw ref-data result expected-message actual-message
                           message list show-raw]})

->test-report clj

(->test-report m s x k)

Given a test report map, a symbolic form, a value (produced from it), and the next report key (:actual or :expected), merge in more elements to build up a test report that clojure.test can use to report the failure, based either on the form or the value, or both.

->vars clj

(->vars ns)

actual-message clj

(actual-message e a str-e str-a)

add-watch-every-iref-for-updates clj

(add-watch-every-iref-for-updates iref-vars)

ansi clj

(ansi code)

ansi-colors clj

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.

by-kind clj

(by-kind vars)

clean-up-exception clj

(clean-up-exception ex)

Given an expected exception, return a simpler representation of it that clojure.test's reporting can display nicely.

color clj

(color code & s)

colorize-choice clj

(colorize-choice)

colorize-filename clj

(colorize-filename s)

colorize-raw clj

(colorize-raw s)

colorize-results clj

(colorize-results pred s)

colorize-warn clj

(colorize-warn s)

compare-expr clj multimethod

context clj macro

(context [sym-kw val & contexts :as args] & forms)

create-context clj

(create-context in-context-vars work)

CustomPred clj protocol

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.

disable-run-on-shutdown clj

(disable-run-on-shutdown)

doexpect clj macro

(doexpect e a)

execute-vars clj

(execute-vars vars)

expanding clj macro

(expanding n)

expect clj macro

(expect a)

(expect e a)

Expectations' equivalent to clojure.test's 'is' macro.

expect-fn clj

(expect-fn e a)

expect-focused clj macro

(expect-focused a)

(expect-focused e a)

expectation-finished clj

(expectation-finished a-var)

expected-message clj

(expected-message e a str-e str-a)

expecting clj macro

(expecting string & body)

The Expectations version of clojure.test/testing.

fail clj

(fail test-name test-meta msg)

find-failures clj

(find-failures the-seq)

find-successes clj

(find-successes the-seq)

finished clj

(finished test-name test-meta)

fold-messages-together clj

(fold-messages-together m)

Given a test report, attempt to fold in additional information from our Expectations report so that clojure.test can provide more details.

freeze-time clj macro

(freeze-time time & forms)

from-each clj macro

(from-each seq-exprs body-expr)

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.

ignored-fns clj

(ignored-fns {:keys [className fileName]})

in clj

(in n)

inc-report-counter clj

(inc-report-counter name)

initial-report-counters clj

localize clj multimethod

message clj

(message e a str-e str-a)

more clj macro

(more & expects)

more-> clj macro

(more-> & expect-pairs)

more-of clj macro

(more-of let-sexp & expect-pairs)

no-op clj

(no-op & _)

ns-finished clj

(ns-finished a-ns)

pp-str clj

(pp-str e)

pruned-stack-trace clj

(pruned-stack-trace t)

raw-str clj

(raw-str [e a])

readme clj

(readme)

(readme readme-path test-path)

If invoked with no arguments, as happens when this namespace is loaded, then based on environment variables and system properties, parse the specified file (normally a readme) and generate a test file based on the Clojure code fragments found inside it. Can also be invoked with the path of the readme source file and the output path for the generated readme.clj test file. This arity is intended for use by tooling that wants to directly control this operation.

redef-state clj macro

(redef-state namespaces & forms)

reminder clj

remove-watch-every-iref-for-updates clj

(remove-watch-every-iref-for-updates iref-vars)

report clj multimethod

run-all-tests clj

(run-all-tests)

(run-all-tests re)

run-tests clj

(run-tests namespaces)

run-tests-in-vars clj

(run-tests-in-vars vars-by-kind)

run-tests-on-shutdown clj

show-raw-choice clj

(show-raw-choice)

side-effects clj macro

(side-effects fn-vec & forms)

started clj

(started test-name test-meta)

string-join clj

(string-join s coll)

strings-difference clj

(strings-difference e a)

summary clj

(summary msg)

test-file clj

(test-file {:keys [file line]})

test-name clj

(test-name {:keys [line ns]})

test-var clj

(test-var v)

test-vars clj

(test-vars vars-by-kind ignored-expectations)

var-kind clj

(var-kind v)