here is some code

(deftest management-tokens-test
  (testing "that we can store, retrieve and delete management tokens"
    (async done
      (with-redefs [aws/store-management-token (fn [cid tok] (local-secrets/put-secret cid tok))
                    aws/fetch-management-token (fn [cid] (local-secrets/get-secret cid))
                    aws/delete-management-token (fn [cid] (local-secrets/delete-secret cid))]
                   (-> (p/let [card-id   (apply str (string/split (str (random-uuid)) #"-"))
                               token     (apply str (reverse card-id))
                               stored    (aws/store-management-token card-id token)
                               fetched   (aws/fetch-management-token card-id)
                               deleted   (aws/delete-management-token card-id true)
                               card-name (str "Modulr/" card-id)]
                         (is (= 200 (get-in stored [:$metadata :httpStatusCode])))
                         (is (= (:Name stored) card-name))
                         (is (= fetched token))
                         (is (= 200 (get-in deleted [:$metadata :httpStatusCode])))
                         (is (= (:Name deleted) card-name)))
                       (p/finally done))))))

am I holding it wrong?

async + with-redefs probably is the issue.

I tried it outside also

user=> (defn foo [] :foo)
#'user/foo
user=> (with-redefs [foo (fn [] :bar)] (foo))
:bar

(deftest management-tokens-test
  (testing "that we can store, retrieve and delete management tokens"
    (with-redefs [aws/store-management-token (fn [cid tok] (local-secrets/put-secret cid tok))
                  aws/fetch-management-token (fn [cid] (local-secrets/get-secret cid))
                  aws/delete-management-token (fn [cid] (local-secrets/delete-secret cid))]
                 (async done
                   (-> (p/let [card-id   (apply str (string/split (str (random-uuid)) #"-"))
                               token     (apply str (reverse card-id))
                               stored    (aws/store-management-token card-id token)
                               fetched   (aws/fetch-management-token card-id)
                               deleted   (aws/delete-management-token card-id true)
                               card-name (str "Modulr/" card-id)]
                         (is (= 200 (get-in stored [:$metadata :httpStatusCode])))
                         (is (= (:Name stored) card-name))
                         (is (= fetched token))
                         (is (= 200 (get-in deleted [:$metadata :httpStatusCode])))
                         (is (= (:Name deleted) card-name)))
                       (p/finally done))))))

your issue is still async + with-redefs

yes

so is that a general problem with CLJS?

yes, how with-redefs works: it restores the bindings at the end of your body. but your work will happen in the future, when the bindings have already been restored

seems like there are some hacks out there ... I'll search a bit more

you can do (alter-var-root #'var old-value) in the finally

this only works in nbb / SCI, not in CLJS (since that doesn't have alter-var-root)

in CLJS you would write (set! ...)

but I still have to support that on global non-dynamic vars in the CLJS side of things

https://github.com/babashka/nbb/issues/136

ah, ok ... let me try the alter-var-root approach

nope, I have no idea how to get this to work

just a minute

(deftest management-tokens-test
  (testing "that we can store, retrieve and delete management tokens"
    (async done
      (-> (p/let [card-id   (apply str (string/split (str (random-uuid)) #"-"))
                  token     (apply str (reverse card-id))
                  stored    (aws/store-management-token card-id token)
                  fetched   (aws/fetch-management-token card-id)
                  deleted   (aws/delete-management-token card-id true)
                  card-name (str "Modulr/" card-id)]
            (is (= 200 (get-in stored [:$metadata :httpStatusCode])))
            (is (= (:Name stored) card-name))
            (is (= fetched token))
            (is (= 200 (get-in deleted [:$metadata :httpStatusCode])))
            (is (= (:Name deleted) card-name)))
          (p/finally
            (do (alter-var-root #'aws/store-management-token (fn [c t] (local-secrets/put-secret c t)))
                (alter-var-root #'aws/fetch-management-token (fn [c] (local-secrets/get-secret c)))
                (alter-var-root #'aws/delete-management-token (fn [c] (local-secrets/delete-secret c)))
                done))))))

You should first capture the old values of the vars and then restore them in the finally

(let [old-fn my-var] ... (p/finally (alter-var-root #'my-var (constantly old-fn)))

ah

but I'm pushing a new version of nbb which will make this slighly easier, just 1 sec

Hmm computer trouble, my kbd stopped working. Was about to publish

Ah, so, in: 0.6.124:

$ node lib/nbb_main.js
Welcome to nbb v0.6.123!
user=>  (defn foo [] 1)
#'user/foo
user=> (let [old-foo foo _ (set! foo (fn [] 2))] (try (foo) (finally (set! foo old-foo))))
2
user=> (foo)
1

I'll reboot my computer....

0.6.124 is being pushed now on CI

okay!!

dumb question perhaps: given that I'm just running a test - why do I need to change everything back?

You don't have to change, that's up to you

It's up to you to screw up and don't revert the screw up, your problem :)

but the inversion is confusing in the async case

you were saying that I have to do the set! in the finally? Or am I missing the point?

just look at my example and it should be clear, right?

https://clojurians.slack.com/archives/C029PTWD3HR/p1657280128135799?thread_ts=1657277685.750859&cid=C029PTWD3HR

your example does not use aync

I thought that's what you said was another issue

it doesn't matter. just replace finally with `p/finally

ok - I'll see what happens 🙂

Something like this, pseudo-code:

(let [old-foo foo] (set! foo (fn [] 2)) (-> (p/do (p/delay 1000) (foo)) (p/finally (set! foo old-foo))

💥

works

nice

Thanks man! I'll buy you an avb at DCD, if not before