clojure
clojure.test

è

Il is macro è il nucleo della clojure.test libreria. Restituisce il valore della sua espressione corporea, stampando un messaggio di errore se l'espressione restituisce un valore falso.

(defn square [x]
  (+ x x))

(require '[clojure.test :as t])

(t/is (= 0 (square 0)))
;;=> true

(t/is (= 1 (square 1)))
;;
;; FAIL in () (foo.clj:1)
;; expected: (= 1 (square 1))
;;   actual: (not (= 1 2))
;;=> false

Raggruppare i test relativi con la macro di test

È possibile raggruppare le asserzioni correlate nei test unitari più deftest all'interno di un contesto utilizzando la macro di testing :

(deftest add-nums 
  (testing "Positive cases"
    (is (= 2 (+ 1 1)))
    (is (= 4 (+ 2 2))))
  (testing "Negative cases"
    (is (= -1 (+ 2 -3)))
    (is (= -4 (+ 8 -12)))))

Ciò contribuirà a chiarire l'output del test durante l'esecuzione. Si noti che il testing deve avvenire all'interno di un punto di deftest .

Definire un test con il risultato migliore

deftest è una macro per la definizione di un test unitario, simile ai test unitari in altre lingue.

È possibile creare un test come segue:

(deftest add-nums
  (is (= 2 (+ 1 1)))
  (is (= 3 (+ 1 2))))

Qui stiamo definendo un test chiamato add-nums , che verifica la funzione + . Il test ha due asserzioni.

È quindi possibile eseguire il test in questo modo nello spazio dei nomi corrente:

(run-tests)

Oppure puoi semplicemente eseguire i test per lo spazio dei nomi in cui si trova il test:

(run-tests 'your-ns)

siamo

L' are macro è anche parte del clojure.test biblioteca. Ti permette di fare più asserzioni su un modello.

Per esempio:

(are [x y] (= x y)  
   4 (+ 2 2)
   8 (* 2 4))
=> true

Qui, (= xy) agisce come un modello che prende ogni argomento e crea una is un'affermazione fuori di esso.

Questo espande multiplo is affermazioni:

(do 
  (is (= 4 (+ 2 2)))
  (is (= 8 (* 2 4))))

Avvolgi ogni test o tutti i test con i dispositivi d'uso

use-fixtures consente di racchiudere ogni deftest nel namespace con il codice che viene eseguito prima e dopo il test. Può essere usato per infissi o stub.

Le fixture sono solo funzioni che prendono la funzione di test e la eseguono con altri passi necessari (prima / dopo, wrap).

(ns myapp.test
  (require [clojure.test :refer :all])

(defn stub-current-thing [body]
  ;; with-redefs stubs things/current-thing function to return fixed
  ;; value for duration of each test
  (with-redefs [things/current-thing (fn [] {:foo :bar})]
    ;; run test body
    (body)))

(use-fixtures :each stub-current-thing)

Se utilizzato con :once , esegue l'intera serie di test nello spazio dei nomi corrente con la funzione

(defn database-for-tests [all-tests]
  (setup-database)
  (all-tests)
  (drop-database))

(use-fixtures :once database-for-tests)

Esecuzione di test con Leiningen

Se si sta utilizzando Leiningen e i test si trovano nella directory di test nella root del progetto, è possibile eseguire i test utilizzando il test lein test