Clojurians Log v2

OK thanks for the further context and pointers! Just a learning curve I have to get over 🙂 While we're at writing tests - do you have some suggestions on writing tests for calling an endpoint? Do you suggest to use something like ring.mock.request or does biff already come with convenience functions? (Thanks for this great package, really makes it quite painless getting started with clojure (web dev))

ring-mock would be fine. In my own tests, I usually call the "base" handler function directly, without going through middleware. i.e. if you have something like this:

(defn foo [request]
  ...)

(def module
  {:routes [["/foo" {:post foo}]]})

Schema:

(def schema
  {
   ;; user attributes
   :user/id :uuid
   :user/email :string

   ;; user entity
   :user [:map {:closed true}
          [:xt/id                     :user/id]
          [:user/email                :string]]})

(ns com.example.models.user
  (:require [com.biffweb :as biff]))

(defn create-user! [ctx email]
  (let [uuid (random-uuid)]
  (biff/submit-tx ctx
                  [{:db/doc-type :user
                    :xt/id uuid
                    :db/op :create
                    :user/email email}])
  uuid))

(defn get-user [{:keys [biff/db]} email]
  (biff/lookup db :user/email email))

(ns com.example.models.user-test
  (:require
   [clojure.test :refer [deftest is]]
   [com.biffweb :as biff :refer [test-xtdb-node]]
   [com.example :as main]
   [xtdb.api :as xt]
   [com.example.models.user :as user]))

(defn get-context [node]
  {:biff.xtdb/node  node
   :biff/db         (xt/db node)
   :biff/malli-opts #'main/malli-opts})

(def bobs-email "bob@example.com")
(def alices-email "alice@example.com")

(deftest get-user
  (with-open [node (test-xtdb-node [{:xt/id (random-uuid) :user/email bobs-email}])]
    (let [ctx (get-context node)
          existing-user (user/get-user ctx bobs-email)
          non-existing-user (user/get-user ctx alices-email)]
      (is (some? existing-user))
      (is (= (:user/email existing-user) bobs-email))
      (is (nil? non-existing-user)))))

(deftest create-user
  (with-open [node (test-xtdb-node [])]
    (let [ctx (get-context node)]
        (let [created-uuid (user/create-user! ctx bobs-email)
              created-user (user/get-user ctx bobs-email)]
          ;; verify we get the uuid after creation
          (is (some? created-user))
          (is (uuid? created-uuid))))))

Looks like "refreshing" the db with xt/db did the trick:

(deftest create-user
  (with-open [node (test-xtdb-node [])]
    (let [ctx (get-context node)]
      (user/create-user! ctx bobs-email)
      (let [db (xt/db node) ;; refresh the db
            ctx (assoc ctx :biff/db db) ;; update the context
            created-user (user/get-user ctx bobs-email)] ;; query user
        ;; verify we get the expected user after creating it
        (is (some? created-user))
        (is (uuid? (:xt/id created-user)))
        (is (= bobs-email (:user/email created-user)))))))

Yep, calling xt/db again is the solution. you can also do (let [ctx (biff/merge-context ctx) ... as a convenience which updates the :biff/db key in ctx. This is needed because db is an immutable value / snapshot of the database at a particular point in time. You can call (xt/db-basis db) to see the time for which the snapshot was made, and you'll see that the db-basis value changes after getting a new db value with xt/db / biff/merge-context. This is a somewhat common pitfall and it's probably worth addressing somehow... in XT2 I think they've set it up so the default approach is you always get the latest DB value, and then if you want a snapshot you can get that explicitly. or something.