|
| 1 | +(local {: describe : it} (require :plenary.busted)) |
| 2 | +(local assert (require :luassert.assert)) |
| 3 | +(local server (require :conjure.client.clojure.nrepl.server)) |
| 4 | +(local state (require :conjure.client.clojure.nrepl.state)) |
| 5 | +(local core (require :nfnl.core)) |
| 6 | + |
| 7 | +(fn make-conn [opts] |
| 8 | + "Create a minimal mock conn object for testing." |
| 9 | + (core.merge |
| 10 | + {:ready? false |
| 11 | + :pending-evals [] |
| 12 | + :setup-timeout nil |
| 13 | + :host "localhost" |
| 14 | + :port 12345 |
| 15 | + :session "test-session" |
| 16 | + :describe {} |
| 17 | + :seen-ns {} |
| 18 | + :send (fn []) |
| 19 | + :destroy (fn [])} |
| 20 | + opts)) |
| 21 | + |
| 22 | +(fn set-conn! [conn] |
| 23 | + (core.assoc (state.get) :conn conn)) |
| 24 | + |
| 25 | +(fn clear-conn! [] |
| 26 | + (core.assoc (state.get) :conn nil)) |
| 27 | + |
| 28 | +(describe "client.clojure.nrepl.server" |
| 29 | + (fn [] |
| 30 | + |
| 31 | + (describe "with-conn-or-warn" |
| 32 | + (fn [] |
| 33 | + (it "calls f when conn exists" |
| 34 | + (fn [] |
| 35 | + (set-conn! (make-conn)) |
| 36 | + (var called? false) |
| 37 | + (server.with-conn-or-warn (fn [_conn] (set called? true))) |
| 38 | + (assert.is_true called?) |
| 39 | + (clear-conn!))) |
| 40 | + |
| 41 | + (it "does not call f when no conn" |
| 42 | + (fn [] |
| 43 | + (clear-conn!) |
| 44 | + (var called? false) |
| 45 | + (server.with-conn-or-warn (fn [_conn] (set called? true)) {:silent? true}) |
| 46 | + (assert.is_false called?))))) |
| 47 | + |
| 48 | + (describe "with-conn-ready-or-queue" |
| 49 | + (fn [] |
| 50 | + (it "calls f immediately when conn is ready" |
| 51 | + (fn [] |
| 52 | + (set-conn! (make-conn {:ready? true})) |
| 53 | + (var called? false) |
| 54 | + (server.with-conn-ready-or-queue (fn [_conn] (set called? true))) |
| 55 | + (assert.is_true called?) |
| 56 | + (clear-conn!))) |
| 57 | + |
| 58 | + (it "queues f when conn is not ready" |
| 59 | + (fn [] |
| 60 | + (let [conn (make-conn {:ready? false})] |
| 61 | + (set-conn! conn) |
| 62 | + (var called? false) |
| 63 | + (server.with-conn-ready-or-queue (fn [_conn] (set called? true))) |
| 64 | + (assert.is_false called?) |
| 65 | + (assert.are.equals 1 (length conn.pending-evals)) |
| 66 | + (clear-conn!)))) |
| 67 | + |
| 68 | + (it "does not call f or queue when no conn" |
| 69 | + (fn [] |
| 70 | + (clear-conn!) |
| 71 | + (var called? false) |
| 72 | + (server.with-conn-ready-or-queue (fn [_conn] (set called? true)) {:silent? true}) |
| 73 | + (assert.is_false called?))))) |
| 74 | + |
| 75 | + (describe "mark-ready!" |
| 76 | + (fn [] |
| 77 | + (it "sets ready? and drains pending evals in order" |
| 78 | + (fn [] |
| 79 | + (let [conn (make-conn {:ready? false}) |
| 80 | + results []] |
| 81 | + (set-conn! conn) |
| 82 | + (table.insert conn.pending-evals (fn [_conn] (table.insert results :first))) |
| 83 | + (table.insert conn.pending-evals (fn [_conn] (table.insert results :second))) |
| 84 | + (table.insert conn.pending-evals (fn [_conn] (table.insert results :third))) |
| 85 | + (server.mark-ready!) |
| 86 | + (assert.is_true conn.ready?) |
| 87 | + (assert.same [:first :second :third] results) |
| 88 | + (assert.are.equals 0 (length conn.pending-evals)) |
| 89 | + (clear-conn!)))) |
| 90 | + |
| 91 | + (it "is idempotent — second call is a no-op" |
| 92 | + (fn [] |
| 93 | + (let [conn (make-conn {:ready? false}) |
| 94 | + call-count {:n 0}] |
| 95 | + (set-conn! conn) |
| 96 | + (table.insert conn.pending-evals (fn [_conn] (set call-count.n (+ call-count.n 1)))) |
| 97 | + (server.mark-ready!) |
| 98 | + (assert.are.equals 1 call-count.n) |
| 99 | + ;; Second call should not drain again. |
| 100 | + (table.insert conn.pending-evals (fn [_conn] (set call-count.n (+ call-count.n 1)))) |
| 101 | + (server.mark-ready!) |
| 102 | + ;; The second pending-eval should NOT have been drained by mark-ready! |
| 103 | + ;; because ready? is already true. |
| 104 | + (assert.are.equals 1 call-count.n) |
| 105 | + (clear-conn!)))) |
| 106 | + |
| 107 | + (it "no-ops when no conn exists" |
| 108 | + (fn [] |
| 109 | + (clear-conn!) |
| 110 | + ;; Should not error. |
| 111 | + (server.mark-ready!))))) |
| 112 | + |
| 113 | + (describe "connected?" |
| 114 | + (fn [] |
| 115 | + (it "returns true when conn exists" |
| 116 | + (fn [] |
| 117 | + (set-conn! (make-conn)) |
| 118 | + (assert.is_true (server.connected?)) |
| 119 | + (clear-conn!))) |
| 120 | + |
| 121 | + (it "returns false when no conn" |
| 122 | + (fn [] |
| 123 | + (clear-conn!) |
| 124 | + (assert.is_false (server.connected?)))))) |
| 125 | + |
| 126 | + (describe "un-comment" |
| 127 | + (fn [] |
| 128 | + (it "strips leading #_ from code" |
| 129 | + (fn [] |
| 130 | + (assert.are.equals "(+ 1 2)" (server.un-comment "#_(+ 1 2)")))) |
| 131 | + |
| 132 | + (it "leaves code without #_ unchanged" |
| 133 | + (fn [] |
| 134 | + (assert.are.equals "(+ 1 2)" (server.un-comment "(+ 1 2)")))) |
| 135 | + |
| 136 | + (it "returns nil for nil input" |
| 137 | + (fn [] |
| 138 | + (assert.are.equals nil (server.un-comment nil)))))))) |
0 commit comments