Useful for making custom assertions.

Declares a function that is invoked after each characteristic in the containing describe scope is evaluated. The body
may consist of any forms, presumably ones that perform side effects.

Declares a function that is invoked once after all the characteristics in the containing describe scope have been
evaluated.  The body may consist of any forms, presumably ones that perform side effects.

Declares a function that will be invoked around each characteristic of the containing describe scope.
The characteristic will be passed in and the around function is responsible for invoking it.

(around [it] (binding [*out* new-out] (it)))

Note that if you have cleanup that must run, use a 'finally' block:

(around [it] (try (it) (finally :clean-up)))

Declares a function that is invoked once around all characteristics of the containing describe scope.

Declares a function that is invoked before each characteristic in the containing describe scope is evaluated. The body
may consist of any forms, presumably ones that perform side effects.

Declares a function that is invoked once before any characteristic in the containing describe scope is evaluated. The
body may consist of any forms, presumably ones that perform side effects.

Same as describe, but should be used to nest testing contexts inside the outer describe.
Contexts can be nested any number of times.

body => & spec-components

Declares a new spec.  The body can contain any forms that evaluate to spec components (it, before, after, with ...).

Same as 'context', but it is meant to facilitate temporary debugging.
Components defined with this macro will be fully executed along with any
other components thus defined, but all other sibling components defined
with 'context' will be ignored.

Same as 'describe', but it is meant to facilitate temporary debugging.
Components defined with this macro will be fully executed along with any
other components thus defined, but all other sibling components defined
with 'describe' will be ignored.

Same as 'it', but it is meant to facilitate temporary debugging.
Characteristics defined with this macro will be executed along with any
other characteristics thus defined, but all other characteristic defined
with 'it' will be ignored.

body => any forms, but should contain at least one assertion (should)

Declares a new characteristic (example in rspec).

When added to a characteristic, it is marked as pending.  If a message is provided it will be printed
in the run report

Redefines the bindings around each characteristic of the containing describe scope.

Asserts the truthy-ness of a form

Asserts that a form satisfies a function.

Asserts that the type of the given form derives from or equals the expected type

Asserts that the form evaluates to nil

Asserts that two forms evaluate to the same object, with the expected value as the first parameter.

Multi-purpose assertion of containment.  Works on strings, regular expressions, sequences, and maps.

(should-contain "foo" "foobar")            ; looks for sub-string
(should-contain #"hello.*" "hello, world") ; looks for regular expression
(should-contain :foo {:foo :bar})          ; looks for a key in a map
(should-contain 3 [1 2 3 4])               ; looks for an object in a collection

Assertion of suffix in strings and sequences.

(should-end-with "foo" "foobar")            ; looks for string suffix
(should-end-with [1 2] [1 2 3 4])               ; looks for a subset at end of collection

Forces a failure. An optional message may be passed in.

Multi-purpose assertion on (count %). Works on strings, sequences, and maps.

(should-have-count 6 "foobar")
(should-have-count 2 [1 2]})
(should-have-count 1 {:foo :bar})
(should-have-count 0 [])
(should-have-count 0 nil)

Checks for invocations of the specified stub.

Options:
  :times - the number of times the stub should have been invoked. nil means at least once. (default: nil)
  :with - a list of arguments that the stubs should have been invoked with.
    If not specified, anything goes.  Special expected arguments include:
     :* - matches anything
     a fn - matches when the actual is the same fn or calling fn with the actual argument returns true

Example:
(let [foo (stub :foo)]
  (should-have-invoked :foo {:with [1] :times 3}) ; fail
  (foo 1)
  (foo 2)
  (should-have-invoked :foo {:with [1] :times 3}) ; fail
  (should-have-invoked :foo {:with [1] :times 1}) ; pass
  (should-have-invoked :foo {:with [2] :times 1}) ; pass
  (should-have-invoked :foo {:times 3}) ; fail
  (should-have-invoked :foo {:times 2}) ; pass
  (should-have-invoked :foo {:times 1}) ; fail
  (should-have-invoked :foo {:with [1]}) ; pass
  (should-have-invoked :foo {:with [2]}) ; pass
  )

Creates a stub, and binds it to the specified var, evaluates the body, and checks the invocations.

(should-invoke reverse {:with [1 2 3] :return []} (reverse [1 2 3]))

See stub and should-have-invoked for valid options.

Asserts the falsy-ness of a form

Asserts that a form does not satisfy a function.

Asserts that the type of the given form does not derived from or equals the expected type

Asserts that the form evaluates to a non-nil value

Asserts that two forms evaluate to different objects, with the unexpected value as the first parameter.

Multi-purpose assertion of non-containment.  See should-contain as an example of opposite behavior.

The inverse of should-end-with.

Multi-purpose assertion on (not= (count %)). Works on strings, sequences, and maps.

(should-not-have-count 1 "foobar")
(should-not-have-count 1 [1 2]})
(should-not-have-count 42 {:foo :bar})
(should-not-have-count 1 [])
(should-not-have-count 1 nil)

Inverse of should-have-invoked.

Options:
  :times - the number of times the stub should not have been invoked. nil means never. (default: nil)
  :with - a list of arguments that the stubs should not have been invoked with.
    If not specified, anything goes. Special expected arguments include:
     :* - matches anything
     a fn - matches when the actual is the same fn or calling fn with the actual argument returns true

Example:
(let [foo (stub :foo)]
  (should-not-have-invoked :foo {:with [1] :times 3}) ; pass
  (foo 1)
  (should-not-have-invoked :foo {:with [1] :times 3}) ; pass
  (should-not-have-invoked :foo {:with [1] :times 1}) ; fail
  (should-not-have-invoked :foo {:times 3}) ; pass
  (should-not-have-invoked :foo {:times 1}) ; fail
  (should-not-have-invoked :foo {:with [1]}) ; fail
  )

Creates a stub, and binds it to the specified var, evaluates the body, and checks that is was NOT invoked.

(should-not-invoke reverse {:with [1 2 3] :return [] :times 2} (reverse [1 2 3])) ; pass
(should-not-invoke reverse {:with [1 2 3] :return []} (reverse [1 2 3])) ; fail

See stub and should-not-have-invoked for valid options.

The inverse of should-start-with.

Asserts that nothing is thrown by the evaluation of a form.

Asserts that two forms evaluate to unequal values, with the unexpected value as the first parameter.

Asserts 'non-equivalency'.
When passed collections it will check that they do NOT have the same contents.
For anything else it will assert that clojure.core/== returns false.

Assertion of prefix in strings and sequences.

(should-start-with "foo" "foobar")            ; looks for string prefix
(should-start-with [1 2] [1 2 3 4])               ; looks for a subset at start of collection

Asserts that a Throwable is throws by the evaluation of a form.
When an class is passed, it asserts that the thrown Exception is an instance of the class.
There are three options for passing different kinds of predicates:
  - If a string, assert that the message of the Exception is equal to the string.
  - If a regex, asserts that the message of the Exception matches the regex.
  - If a function, assert that calling the function on the Exception returns a truthy value.

Asserts that the first numeric form is less than the second numeric form, using the built-in < function.

Asserts that the first numeric form is less than or equal to the second numeric form, using the built-in <= function.

Asserts that two forms evaluate to equal values, with the expected value as the first parameter.

Asserts 'equivalency'.
When passed collections it will check that they have the same contents.
For anything else it will assert that clojure.core/== returns true.

Asserts that the first numeric form is greater than the second numeric form, using the built-in > function.

Asserts that the first numeric form is greater than or equal to the second numeric form, using the built-in >= function.

Creates a stub function.  Each call to the stub will be recorded and can later be looked up using the specified name.

Options:
  :invoke - a function that will be invoked when the stub is invoked.  All the arguments passed to the stub will
    be passed to the :invoke value and its return value returned by the stub.
  :return - a value that will be returned by the stub.  This overrides the result of the :invoke value, if specified.
  :throw - an exception that will be thrown by the stub.

Add tags to the containing context.  All values passed will be converted into keywords.  Contexts can be filtered
at runtime by their tags.

(tags :one :two)

Declares a reference-able symbol that will be lazily evaluated once per characteristic of the containing
describe scope.  The body may contain any forms, the last of which will be the value of the dereferenced symbol.

(with meaning 42)
(it "knows the meaning of life" (should= @meaning (the-meaning-of :life)))

Declares a reference-able symbol that will be evaluated immediately and reset once per characteristic of the containing
describe scope.  The body may contain any forms, the last of which will be the value of the dereferenced symbol.

(def my-num (atom 0))
(with! my-with! (swap! my-num inc))
(it "increments my-num before being accessed" (should= 1 @my-num) (should= 2 @my-with!))

Declares a reference-able symbol that will be lazily evaluated once per context. The body may contain any forms,
 the last of which will be the value of the dereferenced symbol.

(with-all meaning 42)
(it "knows the meaning of life" (should= @meaning (the-meaning-of :life)))

Declares a reference-able symbol that will be immediately evaluated once per context. The body may contain any forms,
 the last of which will be the value of the dereferenced symbol.

(def my-num (atom 0))
(with-all! my-with-all! (swap! my-num inc))
(it "increments my-num before being accessed"
  (should= 1 @my-num)
  (should= 2 @my-with!))
(it "only increments my-num once per context"
  (should= 1 @my-num)
  (should= 2 @my-with!))

Add this to describe/context blocks that use stubs.  It will setup a clean recording environment.

Syntactic shortcut to make the characteristic pending.