main entry point for leiningen

(task/-main)

checker that allows and composition of checkers

(mapv (all even? #(< 3 %)) 1 2 3 4 5) => false false false true false

checker that allows or composition of checkers

(mapv (any even? 1) 1 2 3 4 5) => true true false true false

a checker that returns true for any value

(anything nil) => true

(anything :hello :world) => true

checker that allows approximate verifications

((approx 1) 1.000001) => true

((approx 1) 1.1) => false

((approx 1 0.0000001) 1.001) => false

adds a form to capture test input

checker for maps and vectors

((contains {:a odd? :b even?}) {:a 1 :b 4}) => true

((contains {:a 1 :b even?}) {:a 2 :b 4}) => false

((contains 1 2 3) 1 2 3 4) => true

((contains 1 3) 1 2 3 4) => false

shorthand for checking nested maps and vectors

((contains-in {:a {:b {:c odd?}}}) {:a {:b {:c 1 :d 2}}}) => true

((contains-in odd? {:a {:b even?}}) 3 {:a {:b 4 :c 5}}) => true

checker that allows exact verifications

((exactly 1) 1) => true

((exactly Long) 1) => false

((exactly number?) 1) => false

top level macro for test definitions

returns all facts in namespace

runs main hook for fact form

gets elements of the current fact

fact global getter and setter

(fact:global)

lists all facts in namespace

returns all missing facts for a given namespace

fact ns macro

loads a test namespace

purges all facts in namespace

removes the current fact

runs setup hook for current fact

checks if setup hook has been ran

gets the current fact symbol

runs teardown hook for current fact

adds a template to the file

checker that allows negative composition of checkers

(mapv (is-not even?) 1 2 3 4 5) => true false true false true

combination checker for both maps and vectors

((just {:a odd? :b even?}) {:a 1 :b 4}) => true

((just {:a 1 :b even?}) {:a 1 :b 2 :c 3}) => false

((just 1 2 3 4) 1 2 3 4) => true

((just 1 2 3) 1 2 3 4) => false

((just 3 2 4 1 :in-any-order) 1 2 3 4) => true

shorthand for exactly checking nested maps and vectors

((just-in {:a {:b {:c odd?}}}) {:a {:b {:c 1 :d 2}}}) => false

((just-in odd? {:a {:b even?}}) 3 {:a {:b 4}})

((just-in odd? {:a {:b even?}}) 3 {:a {:b 4}}) => true

output options for test results

(task/print-options) => #{:disable :default :all :current :help}

(task/print-options :default) => #{:print-bulk :print-failed :print-throw}

runs all tests

(task/run :list)

(task/run ’std.lib.foundation) ;; {:files 1, :throw 0, :facts 8, :checks 18, :passed 18, :failed 0} => map?

runs only the tests that have errored

(task/run-errored)

runs the current namespace

load test namespace

runs only failed tests recorded in a saved report file

(task/run:report “.hara/runs/run-1781734545292.edn”)

runs loaded tests

unloads the test namespace

checker that allows loose verifications

((satisfies 1) 1) => true

((satisfies Long) 1) => true

((satisfies number?) 1) => true

((satisfies #{1 2 3}) 1) => true

((satisfies 1 2 3) 1) => false

((satisfies number?) “e”) => false

((satisfies #“hello”) #“hello”) => true

a checker that looks into a ref object

((stores 1) (volatile! 1)) => true

((stores 1) 1) => false

checker that determines if an exception has been thrown

((throws Exception “Hello There”) (res/result {:status :exception :data (Exception. “Hello There”)})) => true

checker that determines if an ex-info has been thrown

((throws-info {:a “hello” :b “there”}) (process/evaluate {:form ’(throw (ex-info “hello” {:a “hello” :b “there”}))})) => true