fix(test): register each test var once per namespace

pkg/rt/core/test.lg

@@ -16,7 +16,11 @@
 (defn register-test! [v]
   (let [n *ns*
         xs (get *registered-tests* n [])]
-    (set! *registered-tests* (assoc *registered-tests* n (conj xs v)))))
+    ;; Register each var once. Re-evaluating a deftest — sending it to the
+    ;; REPL again after an edit — hands us the same var, and appending it
+    ;; a second time would make run-tests run and count that test twice.
+    (when-not (some (fn [x] (= x v)) xs)
+      (set! *registered-tests* (assoc *registered-tests* n (conj xs v))))))
 
 (defmacro deftest [name & body]
   `(do

pkg/rt/generated.sums

@@ -2,4 +2,4 @@
 # Content digest of all .lg + lgbgen sources that feed the .lgb
 # bundle and the lowered Go tree. The genmanifest staleness test
 # fails if this no longer matches the sources on disk.
-c1c6e3a30352271dd54c0c20ff0ba88096771d8ad2d6df48b39655beeac4a7dc
+6fe4e3cf7e853566502ce23e32f943182800a3f0dc34705adc5832983143961d

test/register_test_dedupe_test.lg

@@ -0,0 +1,42 @@
+;; Regression test for duplicate test registration.
+;;
+;; register-test! is called by every deftest evaluation. Re-evaluating a
+;; deftest — the editor flow, where you tweak a test and send it to the
+;; REPL again — used to append the same var to *registered-tests* a second
+;; time, so a later run-tests ran and counted that one test twice.
+;;
+;; Harness note: the registry assertions run inside a binding of
+;; *registered-tests* rather than calling clear-registered-tests!, which
+;; would wipe the registry the enclosing TestRunner is iterating over.
+
+(ns test.register-test-dedupe-test
+  (:require [test :refer :all]))
+
+(def probe-one (fn [] :one))
+(def probe-two (fn [] :two))
+
+(defn- registered-count [f]
+  (binding [test/*registered-tests* {}]
+    (f)
+    (count (get test/*registered-tests* *ns* []))))
+
+(deftest re-registering-the-same-var-is-a-no-op
+  (let [n (registered-count (fn []
+                              (register-test! (var probe-one))
+                              (register-test! (var probe-one))
+                              (register-test! (var probe-one))))]
+    (is (= 1 n))))
+
+(deftest distinct-vars-still-register-separately
+  (let [n (registered-count (fn []
+                              (register-test! (var probe-one))
+                              (register-test! (var probe-two))))]
+    (is (= 2 n))))
+
+(deftest registration-order-is-preserved
+  (let [vs (binding [test/*registered-tests* {}]
+             (register-test! (var probe-one))
+             (register-test! (var probe-two))
+             (register-test! (var probe-one))
+             (get test/*registered-tests* *ns* []))]
+    (is (= [(var probe-one) (var probe-two)] vs))))