code.test — xyz.zcaudate/code.test 4.0.6

+listeners+ clj

-main clj

(-main & args)

main entry point for leiningen

(task/-main)

=> clj

all clj

(all & cks)

checker that allows and composition of checkers

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

any clj

(any & cks)

checker that allows or composition of checkers

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

anything clj

(anything x)

a checker that returns true for any value

(anything nil) => true

(anything [:hello :world]) => true

approx clj

(approx v)

(approx v threshold)

checker that allows approximate verifications

((approx 1) 1.000001) => true

((approx 1) 1.1) => false

((approx 1 0.0000001) 1.001) => false

capture clj macro

(capture)

(capture checker)

(capture checker sym)

adds a form to capture test input

contains clj

(contains x & modifiers)

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

contains-in clj macro

(contains-in x)

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

exactly clj

(exactly v)

(exactly v function)

checker that allows exact verifications

((exactly 1) 1) => true

((exactly Long) 1) => false

((exactly number?) 1) => false

fact clj macro

(fact desc & body)

top level macro for test definitions

fact:all clj macro

(fact:all)

(fact:all ns)

returns all facts in namespace

fact:bench clj macro

(fact:bench)

(fact:bench params & inputs)

runs a small micro bench for the current fact

fact:check clj macro

(fact:check inputs)

runs a check over a range of values

fact:compile clj

(fact:compile fpkg)

(fact:compile fpkg global)

recompiles fact with a different global

fact:derive clj macro

(fact:derive desc)

runs a form derived from a previous test

fact:exec clj macro

(fact:exec)

(fact:exec id)

(fact:exec ns id)

runs main hook for fact form

fact:get clj macro

(fact:get)

(fact:get id)

(fact:get ns id)

gets elements of the current fact

fact:global clj macro

(fact:global)

(fact:global cmd & args)

fact global getter and setter

(fact:global)

fact:let clj macro

(fact:let args)

runs a form that has binding substitutions

fact:list clj

(fact:list)

lists all facts in namespace

fact:missing clj

(fact:missing)

(fact:missing ns)

returns all missing facts for a given namespace

fact:ns clj macro

(fact:ns & forms)

fact ns macro

fact:ns-load clj

(fact:ns-load ns)

loads a test namespace

fact:purge clj

(fact:purge)

purges all facts in namespace

fact:remove clj macro

(fact:remove)

removes the current fact

fact:rerun clj

(fact:rerun facts)

(fact:rerun facts filters)

(fact:rerun facts filters global)

reruns all facts along with filter and compile options

fact:setup clj macro

(fact:setup)

runs setup hook for current fact

fact:setup? clj macro

(fact:setup?)

checks if setup hook has been ran

fact:symbol clj macro

(fact:symbol)

gets the current fact symbol

fact:table clj macro

(fact:table header & inputs)

runs a form with tabular value substitutions

fact:teardown clj macro

(fact:teardown)

runs teardown hook for current fact

fact:template clj macro

(fact:template desc & body)

adds a template to the file

is-not clj

(is-not ck)

(is-not ck function)

checker that allows negative composition of checkers

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

just clj

(just x & modifiers)

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

just-in clj macro

(just-in x)

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

print-options clj

(print-options)

(print-options opts)

output options for test results

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

(task/print-options :default) => #{:print-bulk :print-failure :print-thrown}

run clj

(run)

(run ns)

(run ns params)

(run ns params project)

(run ns params lookup project)

runs all tests

(task/run :list)

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

run-errored clj

(run-errored)

runs only the tests that have errored

(task/run-errored)

run:current clj

(run:current)

(run:current ns)

(run:current ns params)

(run:current ns params project)

(run:current ns params lookup project)

runs the current namespace

run:interrupt clj

(run:interrupt)

run:load clj

(run:load)

(run:load ns)

(run:load ns params)

(run:load ns params project)

(run:load ns params lookup project)

load test namespace

run:test clj

(run:test)

(run:test ns)

(run:test ns params)

(run:test ns params project)

(run:test ns params lookup project)

runs loaded tests

run:unload clj

(run:unload)

(run:unload ns)

(run:unload ns params)

(run:unload ns params project)

(run:unload ns params lookup project)

unloads the test namespace

satisfies clj

(satisfies v)

(satisfies v function)

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

stores clj

(stores v)

a checker that looks into a ref object

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

((stores 1) 1) => false

throws clj

(throws)

(throws e)

(throws e msg)

checker that determines if an exception has been thrown

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

throws-info clj

(throws-info)

(throws-info m)

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