Liking cljdoc? Tell your friends :D

expectations.clojure.test

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.

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.
raw docstring

=?cljmacro

(=? expected actual & [form])

Internal fuzzy-equality test (clojure.test/assert-expr).

Internal fuzzy-equality test (clojure.test/assert-expr).
sourceraw docstring

approximatelyclj

(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.

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.
sourceraw docstring

betweenclj

(between a b)

Given a pair of (numeric) values, return a predicate that expects its argument to be be those values or between them -- inclusively.

Given a pair of (numeric) values, return a predicate that expects its
argument to be be those values or between them -- inclusively.
sourceraw docstring

between'clj

(between' a b)

Given a pair of (numeric) values, return a predicate that expects its argument to be (strictly) between those values -- exclusively.

Given a pair of (numeric) values, return a predicate that expects its
argument to be (strictly) between those values -- exclusively.
sourceraw docstring

defexpectcljmacro

(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.

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.
sourceraw docstring

expectcljmacro

(expect a)
(expect e a)
(expect e a msg)
(expect e a msg ex? e')

Translate Expectations DSL to clojure.test language.

These are approximate translations for the most basic forms:

(expect actual) => (is actual)

(expect expected actual) => (is (= expected actual))

(expect predicate actual) => (is (predicate actual))

(expect regex actual) => (is (re-find regex actual))

(expect ClassName actual) => (is (instance? ClassName actual))

(expect ExceptionType actual) => (is (thrown? ExceptionType actual))

(expect spec actual) => (is (s/valid? spec actual))

An optional third argument can be provided: a message to be included in the output if the test fails.

In addition, actual can be (from-each [x coll] (computation-of x)) or (in set-of-results) or (in larger-hash-map).

Also, expect can be one of (more predicate1 .. predicateN), (more-> exp1 expr1 .. expN exprN) where actual is threaded through each expression exprX and checked with the expected value expX, or (more-of binding exp1 val1 .. expN valN) where actual is destructured using the binding and then each expected value expX is used to check each valX -- expressions based on symbols in the binding.

Translate Expectations DSL to `clojure.test` language.

These are approximate translations for the most basic forms:

`(expect actual)`               => `(is actual)`

`(expect expected actual)`      => `(is (= expected actual))`

`(expect predicate actual)`     => `(is (predicate actual))`

`(expect regex actual)`         => `(is (re-find regex actual))`

`(expect ClassName actual)`     => `(is (instance? ClassName actual))`

`(expect ExceptionType actual)` => `(is (thrown? ExceptionType actual))`

`(expect spec actual)`          => `(is (s/valid? spec actual))`

An optional third argument can be provided: a message to be included
in the output if the test fails.

In addition, `actual` can be `(from-each [x coll] (computation-of x))`
or `(in set-of-results)` or `(in larger-hash-map)`.

Also, `expect` can be one of `(more predicate1 .. predicateN)`,
`(more-> exp1 expr1 .. expN exprN)` where `actual` is threaded through
each expression `exprX` and checked with the expected value `expX`,
or `(more-of binding exp1 val1 .. expN valN)` where `actual` is
destructured using the `binding` and then each expected value `expX`
is used to check each `valX` -- expressions based on symbols in the
`binding`.
sourceraw docstring

expectingcljmacro

(expecting string & body)

The Expectations version of clojure.test/testing.

The Expectations version of `clojure.test/testing`.
sourceraw docstring

from-clojure-testclj

(from-clojure-test f)

Intern the specified symbol from clojure.test as a symbol in expectations.clojure.test with the same value and metadata.

Intern the specified symbol from `clojure.test` as a symbol in
`expectations.clojure.test` with the same value and metadata.
sourceraw docstring

from-eachcljmacro

(from-each bindings & body)

(expect expected (from-each [v coll] (f v))) -- expect this to be true for each element of collection. (f v) is the actual result.

Equivalent to: (doseq [v coll] (expect expected (f v)))

(expect even? (from-each [v (range 10)] (* 2 v)))

from-each may only be used inside expect and is a purely syntactic construct. This macro can be refer'd to satisfy tooling like clj-kondo.

`(expect expected (from-each [v coll] (f v)))` -- expect this to be true
for each element of collection. `(f v)` is the actual result.

Equivalent to: `(doseq [v coll] (expect expected (f v)))`

`(expect even? (from-each [v (range 10)] (* 2 v)))`

`from-each` may only be used inside `expect` and is a purely syntactic construct.
This macro can be `refer`'d to satisfy tooling like `clj-kondo`.
sourceraw docstring

functionallyclj

(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!

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!
sourceraw docstring

humane-test-output?clj

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

This Var will be true if Humane Test Output is available and activated, otherwise it will be nil.

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

This Var will be `true` if Humane Test Output is available and activated,
otherwise it will be `nil`.
sourceraw docstring

incljmacro

(in coll)

(expect expected (in actual)) -- expect a subset of a collection.

If actual is a hash map, expected can be a hash map of key/value pairs that you expect to be in the actual result (there may be other key/value pairs, which are ignored).

If actual is a set, vector, or list, expected can be any value that you expect to be a member of the actual data.

(expect {:b 2} (in {:a 1 :b 2 :c 3})) (expect 2 (in #{1 2 3})) (expect 2 (in [1 2 3]))

in may only be used inside expect and is a purely syntactic construct. This macro can be refer'd to satisfy tooling like clj-kondo.

`(expect expected (in actual))` -- expect a subset of a collection.

If `actual` is a hash map, `expected` can be a hash map of key/value pairs
that you expect to be in the `actual` result (there may be other key/value
pairs, which are ignored).

If `actual` is a set, vector, or list, `expected` can be any value that
you expect to be a member of the `actual` data.

`(expect {:b 2} (in {:a 1 :b 2 :c 3}))`
`(expect 2 (in #{1 2 3}))`
`(expect 2 (in [1 2 3]))`

`in` may only be used inside `expect` and is a purely syntactic construct.
This macro can be `refer`'d to satisfy tooling like `clj-kondo`.
sourceraw docstring

morecljmacro

(more & expecteds)

(expect (more expected1 ...) actual) -- provide multiple expectations on actual as a series of expected results.

Equivalent to: (do (expect expected1 actual) ...)

(expect (more int? even?) 42)

more may only be used inside expect and is a purely syntactic construct. This macro can be refer'd to satisfy tooling like clj-kondo.

`(expect (more expected1 ...) actual)` -- provide multiple expectations
on `actual` as a series of expected results.

Equivalent to: `(do (expect expected1 actual) ...)`

`(expect (more int? even?) 42)`

`more` may only be used inside `expect` and is a purely syntactic construct.
This macro can be `refer`'d to satisfy tooling like `clj-kondo`.
sourceraw docstring

more->cljmacro

(more-> & expected-threaded-pairs)

(expect (more-> expected1 (threaded1) ...) actual) -- provide multiple expectations on actual based on threading it into various expressions.

Equivalent to: (do (expect expected1 (-> actual (threaded1))) ...)

(expect (more-> string? (first) int? (second)) ["test" 42])

more-> may only be used inside expect and is a purely syntactic construct. This macro can be refer'd to satisfy tooling like clj-kondo.

`(expect (more-> expected1 (threaded1) ...) actual)` -- provide multiple
expectations on `actual` based on threading it into various expressions.

Equivalent to: `(do (expect expected1 (-> actual (threaded1))) ...)`

`(expect (more-> string? (first) int? (second)) ["test" 42])`

`more->` may only be used inside `expect` and is a purely syntactic construct.
This macro can be `refer`'d to satisfy tooling like `clj-kondo`.
sourceraw docstring

more-ofcljmacro

(more-of destructuring & expected-actual-pairs)

(expect (more-of destructuring expected1 actual1 ...) actual) -- provide multiple expectations on actual based on binding it against the destructuring expression (like in a let) and then expecting things about its subcomponents.

Equivalent to: (let [destructuring actual] (expect expected1 actual1) ...)

(expect (more-of [a b] string? a int? b) ["test" 42])

more-of may only be used inside expect and is a purely syntactic construct. This macro can be refer'd to satisfy tooling like clj-kondo.

`(expect (more-of destructuring expected1 actual1 ...) actual)` -- provide
multiple expectations on `actual` based on binding it against the
`destructuring` expression (like in a `let`) and then expecting things about
its subcomponents.

Equivalent to: `(let [destructuring actual] (expect expected1 actual1) ...)`

`(expect (more-of [a b] string? a int? b) ["test" 42])`

`more-of` may only be used inside `expect` and is a purely syntactic construct.
This macro can be `refer`'d to satisfy tooling like `clj-kondo`.
sourceraw docstring

run-all-testsclj

(run-all-tests)
(run-all-tests re)

Runs all tests in all namespaces; prints results. Optional argument is a regular expression; only namespaces with names matching the regular expression (with re-matches) will be tested.

Imported from clojure.test.

Runs all tests in all namespaces; prints results.
  Optional argument is a regular expression; only namespaces with
  names matching the regular expression (with re-matches) will be
  tested.

Imported from clojure.test.
sourceraw docstring

run-testsclj

(run-tests)
(run-tests & namespaces)

Runs all tests in the given namespaces; prints results. Defaults to current namespace if none given. Returns a map summarizing test results.

Imported from clojure.test.

Runs all tests in the given namespaces; prints results.
  Defaults to current namespace if none given.  Returns a map
  summarizing test results.

Imported from clojure.test.
sourceraw docstring

side-effectscljmacro

(side-effects fn-vec & forms)

Given a vector of functions to track calls to, execute the body.

Returns a vector of each set of arguments used in calls to those functions. The specified functions will not actually be called: only their arguments will be tracked. If you need the call to return a specific value, the function can be given as a pair of its name and the value you want its call(s) to return. Functions given just by name will return nil.

Given a vector of functions to track calls to, execute the body.

Returns a vector of each set of arguments used in calls to those
functions. The specified functions will not actually be called:
only their arguments will be tracked. If you need the call to return
a specific value, the function can be given as a pair of its name
and the value you want its call(s) to return. Functions given just
by name will return `nil`.
sourceraw docstring

test-all-varsclj

(test-all-vars ns)

Calls test-vars on every var interned in the namespace, with fixtures.

Imported from clojure.test.

Calls test-vars on every var interned in the namespace, with fixtures.

Imported from clojure.test.
sourceraw docstring

test-nsclj

(test-ns ns)

If the namespace defines a function named test-ns-hook, calls that. Otherwise, calls test-all-vars on the namespace. 'ns' is a namespace object or a symbol.

Internally binds report-counters to a ref initialized to initial-report-counters. Returns the final, dereferenced state of report-counters.

Imported from clojure.test.

If the namespace defines a function named test-ns-hook, calls that.
  Otherwise, calls test-all-vars on the namespace.  'ns' is a
  namespace object or a symbol.

  Internally binds *report-counters* to a ref initialized to
  *initial-report-counters*.  Returns the final, dereferenced state of
  *report-counters*.

Imported from clojure.test.
sourceraw docstring

test-varclj

(test-var v)

If v has a function in its :test metadata, calls that function, with testing-vars bound to (conj testing-vars v).

Imported from clojure.test.

If v has a function in its :test metadata, calls that function,
  with *testing-vars* bound to (conj *testing-vars* v).

Imported from clojure.test.
sourceraw docstring

test-varsclj

(test-vars vars)

Groups vars by their namespace and runs test-vars on them with appropriate fixtures applied.

Imported from clojure.test.

Groups vars by their namespace and runs test-vars on them with
   appropriate fixtures applied.

Imported from clojure.test.
sourceraw docstring

use-fixturesclj

(use-fixtures fixture-type & fs)

Wrap test runs in a fixture function to perform setup and teardown. Using a fixture-type of :each wraps every test individually, while :once wraps the whole run in a single function.

Like cljs.test/use-fixtures, also accepts hash maps with :before and/or :after keys that specify 0-arity functions to invoke before/after the test/run.

Wrap test runs in a fixture function to perform setup and
teardown. Using a fixture-type of `:each` wraps every test
individually, while `:once` wraps the whole run in a single function.

Like `cljs.test/use-fixtures`, also accepts hash maps with `:before`
and/or `:after` keys that specify 0-arity functions to invoke
before/after the test/run.
sourceraw docstring

with-testcljmacro

(with-test definition & body)

Takes any definition form (that returns a Var) as the first argument. Remaining body goes in the :test metadata function for that Var.

When load-tests is false, only evaluates the definition, ignoring the tests.

Imported from clojure.test.

Takes any definition form (that returns a Var) as the first argument.
  Remaining body goes in the :test metadata function for that Var.

  When *load-tests* is false, only evaluates the definition, ignoring
  the tests.

Imported from clojure.test.
sourceraw docstring

cljdoc is a website building & hosting documentation for Clojure/Script libraries

× close