clojure.core/with-redefs

View this page on ClojureDocs

Type: macro Added: Clojure 1.3 Examples: 7 Runnable: 1

([bindings & body])

binding => var-symbol temp-value-expr

Temporarily redefines Vars while executing the body. The temp-value-exprs will be evaluated and each resulting value will replace in parallel the root value of its Var. After the body is executed, the root values of all the Vars will be set back to their old values. These temporary changes will be visible in all threads. Useful for mocking out functions during testing.

Examples

by devn on 2012-04-28 . May have evaluation errors. ▶

[(type []) (class [])] [clojure.lang.PersistentVector clojure.lang.PersistentVector] (with-redefs [type (constantly java.lang.String) class (constantly 10)] [(type []) (class [])]) [java.lang.String 10]

by johnnyluu on 2012-10-12 ▶

(ns http) (defn post [url] {:body "Hello world"}) (ns app (:require [clojure.test :refer [deftest is run-tests]])) (deftest is-a-macro (with-redefs [http/post (fn [url] {:body "Goodbye world"})] (is (= {:body "Goodbye world"} (http/post "http://service.com/greet"))))) (run-tests) ;; test is passing

by w01fe on 2012-11-09 . May have evaluation errors. ▶

;; be careful, with-redefs can permanently change a var if applied concurrently: (defn ten [] 10) #'user/ten (doall (pmap #(with-redefs [ten (fn [] %)] (ten)) (range 20 100))) ... (ten) 79

by nickzam on 2014-07-10 . May have evaluation errors. ▶

;; redefine var (def foo 1) #'user/foo (with-redefs [foo 2] foo) 2 ;; redefine private var (ns first) (def ^:private foo 1) #'first/foo (ns second) (with-redefs [first/foo 2] @#'first/foo) 2 ;; @#' is the macros of (deref (var first/foo)) (with-redefs [first/foo 2] (deref (var first/foo)) 2

by deadghost on 2021-07-08 . May have evaluation errors. ▶

;; Vars return to their previous value outside of `with-redefs` body (with-redefs [first last] (first [1 2])) ;; => 2 ((with-redefs [first last] #(first [1 2]))) ;; => 1

by owenRiddy on 2022-07-23 . May have evaluation errors. ▶

;; Macros are not stored in vars, so `with-redefs` doesn't work on them. (defmacro a [] 1) => #'user/a (a) => 1 (with-redefs [a (constantly 2)] (a)) => 1 ;; Inlined functions are also not affected in their inlined form: (defn b {:inline (fn [_] 1)} [_] 1) (with-redefs [b (constantly 2)] (b :foo)) => 1 ;; but their non-inlined form will be affected: (with-redefs [b (constantly 2)] (map b [:foo :bar])) => (2 2)

by tomdl89 on 2025-12-22 . May have evaluation errors. ▶

;; "…each resulting value will replace in parallel the root value of its Var." ;; "parallel" means redefs can't reference each other: (def foo :f) (def bar :b) (with-redefs [foo :e, bar foo] bar) ;; => :f ;; n.b. bar gets foo's original value, not its redeffed value

See also

• clojure.core/with-redefs-fn (0)
• clojure.core/alter-var-root (2)
• clojure.core/with-bindings

---

Content from the matching ClojureDocs page, with authors credited on each contribution.