mirror of
https://github.com/status-im/reagent.git
synced 2025-01-13 13:24:47 +00:00
3fca2e5d41
Reactions now put themselves in a queue when they get a callback from an atom. The queue is flushed before rendering, and on deref on individual reactions. This turns out to perform much better in many cases.
238 lines
6.6 KiB
Clojure
238 lines
6.6 KiB
Clojure
(ns reagenttest.testwithlet
|
|
(:require [cljs.test :as t :refer-macros [is deftest testing]]
|
|
[reagent.ratom :as rv]
|
|
[reagent.debug :as d :refer-macros [dbg]]
|
|
[reagent.core :as r
|
|
:refer [flush track track! dispose!] :refer-macros [with-let]]
|
|
[clojure.walk :as w]))
|
|
|
|
(defn fixture [f]
|
|
(set! rv/debug true)
|
|
(f)
|
|
(set! rv/debug false))
|
|
|
|
(t/use-fixtures :once fixture)
|
|
|
|
(defn running []
|
|
(r/flush)
|
|
(rv/running))
|
|
|
|
(deftest basic-with-let
|
|
(let [runs (running)
|
|
n1 (atom 0)
|
|
n2 (atom 0)
|
|
n3 (atom 0)
|
|
a (r/atom 10)
|
|
f1 (fn []
|
|
(with-let [v (swap! n1 inc)]
|
|
(swap! n2 inc)
|
|
[@a v]
|
|
(finally
|
|
(swap! n3 inc))))
|
|
r (atom nil)
|
|
t (track! (fn []
|
|
(reset! r @(track f1))))]
|
|
(is (= [[10 1] 1 1 0] [@r @n1 @n2 @n3]))
|
|
(swap! a inc)
|
|
(is (= [[10 1] 1 1 0] [@r @n1 @n2 @n3]))
|
|
(flush)
|
|
(is (= [[11 1] 1 2 0] [@r @n1 @n2 @n3]))
|
|
(is (= [11 1] @t))
|
|
|
|
(dispose! t)
|
|
(is (= [[11 1] 1 2 1] [@r @n1 @n2 @n3]))
|
|
(is (= runs (running)))
|
|
|
|
(swap! a inc)
|
|
(flush)
|
|
(is (= [[11 1] 1 2 1] [@r @n1 @n2 @n3]))
|
|
|
|
(is (= [12 2] @t))
|
|
(is (= [[12 2] 2 3 2] [@r @n1 @n2 @n3]))
|
|
|
|
(is (= [12 3] (f1)))
|
|
(is (= [[12 2] 3 4 3] [@r @n1 @n2 @n3]))
|
|
|
|
(is (= runs (running)))))
|
|
|
|
|
|
(deftest test-with-let-args
|
|
(let [runs (running)
|
|
n1 (atom 0)
|
|
n2 (atom 0)
|
|
a (r/atom 0)
|
|
ran (fn []
|
|
(swap! n2 inc)
|
|
@a)
|
|
f1 #(with-let []
|
|
(ran)
|
|
[])
|
|
f2 #(with-let [x1 (swap! n1 inc)]
|
|
(ran)
|
|
[x1])
|
|
f3 #(with-let [x1 (swap! n1 inc)
|
|
x2 (swap! n1 inc)]
|
|
(ran)
|
|
[x1 x2])
|
|
f4 #(with-let [x1 (swap! n1 inc)
|
|
x2 (swap! n1 inc)
|
|
x3 (swap! n1 inc)]
|
|
(ran)
|
|
[x1 x2 x3])
|
|
f5 #(with-let [x1 (swap! n1 inc)
|
|
x2 (swap! n1 inc)
|
|
x3 (swap! n1 inc)
|
|
x4 (swap! n1 inc)]
|
|
(ran)
|
|
[x1 x2 x3 x4])
|
|
f6 #(with-let [x1 (swap! n1 inc)
|
|
x2 (swap! n1 inc)
|
|
x3 (swap! n1 inc)
|
|
x4 (swap! n1 inc)
|
|
x5 (swap! n1 inc)]
|
|
(ran)
|
|
[x1 x2 x3 x4 x5])
|
|
f7 #(with-let [x1 (swap! n1 inc)
|
|
x2 (swap! n1 inc)
|
|
x3 (swap! n1 inc)
|
|
x4 (swap! n1 inc)
|
|
x5 (swap! n1 inc)
|
|
x6 (swap! n1 inc)]
|
|
(ran)
|
|
[x1 x2 x3 x4 x5 x6])
|
|
r (atom nil)
|
|
all (fn [] {:f1 @(track f1)
|
|
:f2 @(track f2)
|
|
:f3 @(track f3)
|
|
:f4 @(track f4)
|
|
:f5 @(track f5)
|
|
:f6 @(track f6)
|
|
:f7 @(track f7)})
|
|
t (track! (fn [] (reset! r (all))))
|
|
expected {:f1 []
|
|
:f2 [1]
|
|
:f3 [2 3]
|
|
:f4 [4 5 6]
|
|
:f5 [7 8 9 10]
|
|
:f6 [11 12 13 14 15]
|
|
:f7 [16 17 18 19 20 21]}]
|
|
(is (< runs (running)))
|
|
(is (= @n2 7))
|
|
(is (= @r expected))
|
|
(is (= (all) expected))
|
|
(is (= @t expected))
|
|
(swap! a inc)
|
|
(is (= @n2 7))
|
|
(flush)
|
|
(is (= @n2 14))
|
|
(is (= @r expected))
|
|
(is (= (all) expected))
|
|
(is (= @t expected))
|
|
(is (= @n2 14))
|
|
(dispose! t)
|
|
(is (= runs (running)))
|
|
(is (= @r expected))
|
|
(is (= @n2 14))
|
|
(is (= (all) (w/postwalk #(if (number? %) (+ 21 %) %)
|
|
expected)))
|
|
(is (= @n2 21))
|
|
(is (= @t (w/postwalk #(if (number? %) (+ 42 %) %)
|
|
expected)))
|
|
(is (= @n2 28))
|
|
(is (= runs (running)))))
|
|
|
|
(deftest non-reactive-with-let
|
|
(let [n1 (atom 0)
|
|
n2 (atom 0)
|
|
n3 (atom 0)
|
|
n4 (atom 0)
|
|
f1 (fn []
|
|
(with-let []
|
|
(swap! n2 inc)))
|
|
f2 (fn []
|
|
(with-let [v (swap! n1 inc)]
|
|
v))
|
|
f3 (fn []
|
|
(with-let [v (swap! n1 inc)]
|
|
(swap! n2 inc)
|
|
(finally (swap! n3 inc))))
|
|
f4 (fn []
|
|
(with-let []
|
|
(finally (swap! n3 inc)
|
|
(swap! n4 inc))))
|
|
f5 (fn []
|
|
[(f1) (f2) (f4)])
|
|
tst (fn [f]
|
|
[(f) @n1 @n2 @n3])]
|
|
(is (= [1 0 1 0] (tst f1)))
|
|
(is (= [1 1 1 0] (tst f2)))
|
|
(is (= [2 2 2 1] (tst f3)))
|
|
(is (= 0 @n4))
|
|
(is (= [nil 2 2 2] (tst f4)))
|
|
(is (= 1 @n4))
|
|
(is (= [[3 3 nil] 3 3 3] (tst f5)))))
|
|
|
|
(deftest with-let-args
|
|
(let [runs (running)
|
|
active (atom 0)
|
|
n1 (atom 0)
|
|
f1 (fn [x y]
|
|
(with-let [_ (swap! active inc)
|
|
v (r/atom @x)]
|
|
(swap! n1 inc)
|
|
(+ y @v)
|
|
(finally
|
|
(reset! v nil)
|
|
(swap! active dec))))
|
|
f2 (fn [x y]
|
|
(with-let [t1 (track f1 x y)
|
|
t2 (track f1 x y)]
|
|
(let [v @(track f1 x y)]
|
|
(is (= v @t1 @t2))
|
|
v)))
|
|
f2t (partial track f2)
|
|
res (atom nil)
|
|
val (r/atom 1)
|
|
valtrack (track deref val)
|
|
t (track! #(reset! res (let [v valtrack]
|
|
(if (> @v 2)
|
|
[@(f2t v 10)]
|
|
[@(f2t val 0)
|
|
@(f2t val 0)
|
|
@(f2t v 10)
|
|
(f1 v 10)]))))]
|
|
(is (= [1 1 11 11] @res))
|
|
(is (= [3 3] [@n1 @active]))
|
|
(reset! val 1)
|
|
(flush)
|
|
(is (= [1 1 11 11] @res))
|
|
(is (= [3 3] [@n1 @active]))
|
|
|
|
(swap! val inc)
|
|
(is (= [3 3] [@n1 @active]))
|
|
(flush)
|
|
(is (= [6 3] [@n1 @active]))
|
|
(is (= [1 1 11 11] @res))
|
|
|
|
(swap! val inc)
|
|
(flush)
|
|
(is (= [6 1] [@n1 @active]))
|
|
(is (= [11] @res))
|
|
|
|
(dispose! t)
|
|
(is (= [6 0] [@n1 @active]))
|
|
(is (= runs (running)))))
|
|
|
|
(deftest with-let-warning
|
|
(when (d/dev?)
|
|
(let [f1 (fn []
|
|
(with-let [a 1]))
|
|
w (d/track-warnings
|
|
(fn []
|
|
(track! (fn []
|
|
(f1)
|
|
(f1)))))]
|
|
(is (= w {:error (list (str "Warning: The same with-let is being "
|
|
"used more than once in the same reactive "
|
|
"context."))})))))
|