expectations — expectations 2.2.0-rc3

*prune-stacktrace* clj/s

*report-counters* clj/s

*test-meta* clj/s

*test-name* clj/s

*test-var* clj/s

->failure-message clj/s

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

->vars clj

(->vars ns)

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

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

ansi clj/s

(ansi code)

ansi-colors clj/s

approximately clj/s

(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/s

(by-kind vars)

color clj/s

(color code & s)

colorize-choice clj/s

(colorize-choice)

colorize-filename clj/s

(colorize-filename s)

colorize-raw clj/s

(colorize-raw s)

colorize-results clj/s

(colorize-results pred s)

colorize-warn clj/s

(colorize-warn s)

compare-expr clj/s multimethod

context clj macro

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

create-context clj/s

(create-context in-context-vars work)

CustomPred clj/s≠ protocol

actual-message clj/s

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

expect-fn clj/s

(expect-fn e a)

expected-message clj/s

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

message clj/s

(message e a str-e str-a)

disable-run-on-shutdown clj/s

(disable-run-on-shutdown)

doexpect clj macro

(doexpect e a)

execute-vars clj/s

(execute-vars vars)

expanding clj macro

(expanding n)

expect clj macro

(expect a)

(expect e a)

expect-focused clj macro

(expect-focused a)

(expect-focused e a)

expectation-finished clj/s

(expectation-finished a-var)

fail clj/s

(fail test-name test-meta msg)

find-failures clj/s

(find-failures the-seq)

find-successes clj/s

(find-successes the-seq)

finished clj/s

(finished test-name test-meta)

freeze-time clj macro

(freeze-time time & forms)

from-each clj macro

(from-each seq-exprs body-expr)

Functionally cljs

functionally clj/s

(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/s

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

in clj/s

(in n)

inc-report-counter clj/s

(inc-report-counter name)

initial-report-counters clj/s

localize clj/s multimethod

more clj macro

(more & expects)

more-> clj macro

(more-> & expect-pairs)

more-of clj macro

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

no-op clj/s

(no-op & _)

ns-finished clj/s

(ns-finished a-ns)

pp-str clj/s

(pp-str e)

pruned-stack-trace clj/s

(pruned-stack-trace t)

raw-str clj/s

(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/s

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

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

report clj/s multimethod

run-all-tests clj

(run-all-tests)

(run-all-tests re)

run-tests clj

(run-tests namespaces)

run-tests-in-vars clj/s

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

run-tests-on-shutdown clj/s

show-raw-choice clj/s

(show-raw-choice)

side-effects clj macro

(side-effects fn-vec & forms)

started clj/s

(started test-name test-meta)

string-join clj/s

(string-join s coll)

strings-difference clj/s

(strings-difference e a)

summary clj/s

(summary msg)

test-file clj/s

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

test-name clj/s

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

test-var clj/s

(test-var v)

test-vars clj/s

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

var-kind clj/s

(var-kind v)

warn-on-iref-updates clj/s

(warn-on-iref-updates)

warn-on-iref-updates-boolean clj/s