datahike-browser-tests 1.0.0

package/test/datahike/test/entity_test.cljc

@@ -0,0 +1,103 @@
+(ns datahike.test.entity-test
+  (:require
+   [#?(:cljs cljs.reader :clj clojure.edn) :as edn]
+   #?(:cljs [cljs.test    :as t :refer-macros [is deftest testing]]
+      :clj  [clojure.test :as t :refer        [is deftest testing]])
+   [clojure.walk]
+   [datahike.api :as d]
+   [datahike.db :as db]
+   [datahike.impl.entity :as de]
+   [datahike.test.core-test :as tdc]))
+
+#?(:cljs (def Throwable js/Error))
+
+(t/use-fixtures :once tdc/no-namespace-maps)
+
+(deftest test-entity
+  (let [db (-> (db/empty-db {:aka {:db/cardinality :db.cardinality/many}})
+               (d/db-with [{:db/id 1, :name "Ivan", :age 19, :aka ["X" "Y"]}
+                           {:db/id 2, :name "Ivan", :sex "male", :aka ["Z"]}
+                           [:db/add 3 :huh? false]]))
+        e  (d/entity db 1)]
+    (is (= (:db/id e) 1))
+    (is (identical? (d/entity-db e) db))
+    (is (= (:name e) "Ivan"))
+    (is (= (e :name) "Ivan")) ; IFn form
+    (is (= (:age  e) 19))
+    (is (= (:aka  e) #{"X" "Y"}))
+    (is (= true (contains? e :age)))
+    (is (= false (contains? e :not-found)))
+    (is (= (into {} e)
+           {:name "Ivan", :age 19, :aka #{"X" "Y"}}))
+    (is (= (into {} (d/entity db 1))
+           {:name "Ivan", :age 19, :aka #{"X" "Y"}}))
+    (is (= (into {} (d/entity db 2))
+           {:name "Ivan", :sex "male", :aka #{"Z"}}))
+    (let [e3 (d/entity db 3)]
+      (is (= (into {} e3) {:huh? false})) ; Force caching.
+      (is (false? (:huh? e3))))
+
+    (is (= (pr-str (d/entity db 1)) "{:db/id 1}"))
+    (is (= (pr-str (let [e (d/entity db 1)] (:unknown e) e)) "{:db/id 1}"))
+    ;; read back in to account for unordered-ness
+    (is (= (edn/read-string (pr-str (let [e (d/entity db 1)] (:name e) e)))
+           (edn/read-string "{:name \"Ivan\", :db/id 1}")))))
+
+(deftest test-entity-refs
+  (let [db (-> (db/empty-db {:father   {:db/valueType   :db.type/ref}
+                             :children {:db/valueType   :db.type/ref
+                                        :db/cardinality :db.cardinality/many}})
+               (d/db-with
+                [{:db/id 1, :children [10]}
+                 {:db/id 10, :father 1, :children [100 101]}
+                 {:db/id 100, :father 10}
+                 {:db/id 101, :father 10}]))
+        e  #(d/entity db %)]
+
+    (is (= (:children (e 1))   #{(e 10)}))
+    (is (= (:children (e 10))  #{(e 100) (e 101)}))
+
+    (testing "empty attribute"
+      (is (= (:children (e 100)) nil)))
+
+    (testing "nested navigation"
+      (is (= (-> (e 1) :children first :children) #{(e 100) (e 101)}))
+      (is (= (-> (e 10) :children first :father) (e 10)))
+      (is (= (-> (e 10) :father :children) #{(e 10)}))
+
+      (testing "after touch"
+        (let [e1  (e 1)
+              e10 (e 10)]
+          (de/touch e1)
+          (de/touch e10)
+          (is (= (-> e1 :children first :children) #{(e 100) (e 101)}))
+          (is (= (-> e10 :children first :father) (e 10)))
+          (is (= (-> e10 :father :children) #{(e 10)})))))
+
+    (testing "backward navigation"
+      (is (= (:_children (e 1))  nil))
+      (is (= (:_father   (e 1))  #{(e 10)}))
+      (is (= (:_children (e 10)) #{(e 1)}))
+      (is (= (:_father   (e 10)) #{(e 100) (e 101)}))
+      (is (= (-> (e 100) :_children first :_children) #{(e 1)})))))
+
+(deftest test-entity-misses
+  (let [db (-> (db/empty-db {:name {:db/unique :db.unique/identity}})
+               (d/db-with [{:db/id 1, :name "Ivan"}
+                           {:db/id 2, :name "Oleg"}]))]
+    (is (nil? (d/entity db nil)))
+    (is (nil? (d/entity db "abc")))
+    (is (nil? (d/entity db :keyword)))
+    (is (nil? (d/entity db [:name "Petr"])))
+    (is (= 777 (:db/id (d/entity db 777))))
+    (is (thrown-with-msg? Throwable #"Lookup ref attribute should be marked as :db/unique: \[:not-an-attr 777\]"
+                          (d/entity db [:not-an-attr 777])))))
+
+(deftest test-entity-walk
+  (let [ivan {:name "Ivan", :age 19, :aka #{"X" "Y"}}
+        db (-> (db/empty-db {:aka {:db/cardinality :db.cardinality/many}})
+               (d/db-with [(assoc ivan :db/id 1)]))
+        e  (d/entity db 1)]
+    (is (= (clojure.walk/walk identity identity e) ivan))
+    (is (= (clojure.walk/postwalk identity e) ivan))
+    (is (= (clojure.walk/prewalk identity e) ivan))))

package/test/datahike/test/explode_test.cljc

@@ -0,0 +1,143 @@
+(ns datahike.test.explode-test
+  (:require
+   #?(:cljs [cljs.test    :as t :refer-macros [is are deftest testing]]
+      :clj  [clojure.test :as t :refer        [is are deftest testing]])
+   [datahike.api :as d]
+   [datahike.db :as db]
+   [datahike.test.utils :as dtu]
+   [datahike.test.core-test]))
+
+#?(:cljs
+   (def Throwable js/Error))
+
+(deftest test-explode
+  (doseq [coll [["Devil" "Tupen"]
+                #{"Devil" "Tupen"}
+                '("Devil" "Tupen")
+                (to-array ["Devil" "Tupen"])]]
+    (testing coll
+      (let [conn (dtu/setup-db {:initial-tx [{:db/ident :aka
+                                              :db/valueType :db.type/string
+                                              :db/cardinality :db.cardinality/many}
+                                             {:db/ident :also
+                                              :db/valueType :db.type/string
+                                              :db/cardinality :db.cardinality/many}]})]
+        (d/transact conn {:tx-data [{:db/id -1
+                                     :name  "Ivan"
+                                     :age   16
+                                     :aka   coll
+                                     :also  "ok"}]})
+        (is (= (d/q '[:find  ?n ?a
+                      :where
+                      [3 :name ?n]
+                      [3 :age ?a]]
+                    @conn)
+               #{["Ivan" 16]}))
+        (is (= (d/q '[:find  ?v
+                      :where [3 :also ?v]]
+                    @conn)
+               #{["ok"]}))
+        (is (= (d/q '[:find  ?v
+                      :where [3 :aka ?v]]
+                    @conn)
+               #{["Devil"] ["Tupen"]}))))))
+
+(deftest test-explode-ref
+  (let [db0 (db/empty-db {:children {:db/valueType :db.type/ref
+                                     :db/cardinality :db.cardinality/many}})]
+    (let [db (d/db-with db0 [{:db/id -1, :name "Ivan", :children [-2 -3]}
+                             {:db/id -2, :name "Petr"}
+                             {:db/id -3, :name "Evgeny"}])]
+      (is (= (d/q '[:find ?n
+                    :where [_ :children ?e]
+                    [?e :name ?n]] db)
+             #{["Petr"] ["Evgeny"]})))
+
+    (let [db (d/db-with db0 [{:db/id -1, :name "Ivan"}
+                             {:db/id -2, :name "Petr", :_children -1}
+                             {:db/id -3, :name "Evgeny", :_children -1}])]
+      (is (= (d/q '[:find ?n
+                    :where [_ :children ?e]
+                    [?e :name ?n]] db)
+             #{["Petr"] ["Evgeny"]})))
+
+    (is (thrown-with-msg? Throwable
+                          #"Bad attribute :_parent: reverse attribute name requires \{:db/valueType :db.type/ref\} in schema"
+                          (d/db-with db0 [{:name "Sergey" :_parent 1}])))))
+
+(deftest test-explode-nested-maps
+  (let [schema {:profile {:db/valueType :db.type/ref}}
+        db     (db/empty-db schema)]
+    (are [tx res] (= (d/q '[:find ?e ?a ?v
+                            :where [?e ?a ?v]]
+                          (d/db-with db tx)) res)
+      [{:db/id 5 :name "Ivan" :profile {:db/id 7 :email "@2"}}]
+      #{[5 :name "Ivan"] [5 :profile 7] [7 :email "@2"]}
+
+      [{:name "Ivan" :profile {:email "@2"}}]
+      #{[1 :name "Ivan"] [1 :profile 2] [2 :email "@2"]}
+
+      [{:profile {:email "@2"}}] ;; issue #59
+      #{[1 :profile 2] [2 :email "@2"]}
+
+      [{:email "@2" :_profile {:name "Ivan"}}]
+      #{[1 :email "@2"] [2 :name "Ivan"] [2 :profile 1]}))
+
+  (testing "multi-valued"
+    (let [schema {:profile {:db/valueType :db.type/ref
+                            :db/cardinality :db.cardinality/many}}
+          db     (db/empty-db schema)]
+      (are [tx res] (= (d/q '[:find ?e ?a ?v
+                              :where [?e ?a ?v]]
+                            (d/db-with db tx)) res)
+        [{:db/id 5 :name "Ivan" :profile {:db/id 7 :email "@2"}}]
+        #{[5 :name "Ivan"] [5 :profile 7] [7 :email "@2"]}
+
+        [{:db/id 5 :name "Ivan" :profile [{:db/id 7 :email "@2"} {:db/id 8 :email "@3"}]}]
+        #{[5 :name "Ivan"] [5 :profile 7] [7 :email "@2"] [5 :profile 8] [8 :email "@3"]}
+
+        [{:name "Ivan" :profile {:email "@2"}}]
+        #{[1 :name "Ivan"] [1 :profile 2] [2 :email "@2"]}
+
+        [{:name "Ivan" :profile [{:email "@2"} {:email "@3"}]}]
+        #{[1 :name "Ivan"] [1 :profile 2] [2 :email "@2"] [1 :profile 3] [3 :email "@3"]}
+
+        [{:email "@2" :_profile {:name "Ivan"}}]
+        #{[1 :email "@2"] [2 :name "Ivan"] [2 :profile 1]}
+
+        [{:email "@2" :_profile [{:name "Ivan"} {:name "Petr"}]}]
+        #{[1 :email "@2"] [2 :name "Ivan"] [2 :profile 1] [3 :name "Petr"] [3 :profile 1]}))))
+
+(deftest test-circular-refs
+  (let [schema {:comp {:db/valueType   :db.type/ref
+                       :db/cardinality :db.cardinality/many
+                       :db/isComponent true}}
+        db     (d/db-with (db/empty-db schema)
+                          [{:db/id 1, :comp [{:name "C"}]}])]
+    (is (= (mapv (juxt :e :a :v) (d/datoms db :eavt))
+           [[1 :comp 2]
+            [2 :name "C"]])))
+
+  (let [schema {:comp {:db/valueType   :db.type/ref
+                       :db/cardinality :db.cardinality/many}}
+        db     (d/db-with (db/empty-db schema)
+                          [{:db/id 1, :comp [{:name "C"}]}])]
+    (is (= (mapv (juxt :e :a :v) (d/datoms db :eavt))
+           [[1 :comp 2]
+            [2 :name "C"]])))
+
+  (let [schema {:comp {:db/valueType   :db.type/ref
+                       :db/isComponent true}}
+        db     (d/db-with (db/empty-db schema)
+                          [{:db/id 1, :comp {:name "C"}}])]
+    (is (= (mapv (juxt :e :a :v) (d/datoms db :eavt))
+           [[1 :comp 2]
+            [2 :name "C"]])))
+
+  (let [schema {:comp {:db/valueType   :db.type/ref}}
+        db     (d/db-with (db/empty-db schema)
+                          [{:db/id 1, :comp {:name "C"}}])]
+    (is (= (mapv (juxt :e :a :v) (d/datoms db :eavt))
+           [[1 :comp 2]
+            [2 :name "C"]]))))
+

package/test/datahike/test/filter_test.cljc

@@ -0,0 +1,75 @@
+(ns datahike.test.filter-test
+  (:require
+   #?(:cljs [cljs.test    :as t :refer-macros [is are deftest testing]]
+      :clj  [clojure.test :as t :refer        [is are deftest testing]])
+   [datahike.api :as d]
+   [datahike.db :as db]))
+
+(deftest test-filter-db
+  (let [empty-db (db/empty-db {:aka {:db/cardinality :db.cardinality/many}})
+        db (-> empty-db
+               (d/db-with [{:db/id 1
+                            :name  "Petr"
+                            :email "petya@spb.ru"
+                            :aka   ["I" "Great"]
+                            :password "<SECRET>"}
+                           {:db/id 2
+                            :name  "Ivan"
+                            :aka   ["Terrible" "IV"]
+                            :password "<PROTECTED>"}
+                           {:db/id 3
+                            :name  "Nikolai"
+                            :aka   ["II"]
+                            :password "<UNKNOWN>"}]))
+        remove-pass (fn [_ datom] (not= :password (:a datom)))
+        remove-ivan (fn [_ datom] (not= 2 (:e datom)))
+        long-akas   (fn [udb datom] (or (not= :aka (:a datom))
+                                        ;; has just 1 aka
+                                        (<= (count (:aka (d/entity udb (:e datom)))) 1)
+                                        ;; or aka longer than 4 chars
+                                        (>= (count (:v datom)) 4)))]
+
+    (are [_db _res] (= (d/q '[:find ?v :where [_ :password ?v]] _db) _res)
+      db                        #{["<SECRET>"] ["<PROTECTED>"] ["<UNKNOWN>"]}
+      (d/filter db remove-pass) #{}
+      (d/filter db remove-ivan) #{["<SECRET>"] ["<UNKNOWN>"]}
+      (-> db (d/filter remove-ivan) (d/filter remove-pass)) #{})
+
+    (are [_db _res] (= (d/q '[:find ?v :where [_ :aka ?v]] _db) _res)
+      db                        #{["I"] ["Great"] ["Terrible"] ["IV"] ["II"]}
+      (d/filter db remove-pass) #{["I"] ["Great"] ["Terrible"] ["IV"] ["II"]}
+      (d/filter db remove-ivan) #{["I"] ["Great"] ["II"]}
+      (d/filter db long-akas)   #{["Great"] ["Terrible"] ["II"]}
+      (-> db (d/filter remove-ivan) (d/filter long-akas)) #{["Great"] ["II"]}
+      (-> db (d/filter long-akas) (d/filter remove-ivan)) #{["Great"] ["II"]})
+
+    (testing "Entities"
+      (is (= (:password (d/entity db 1)) "<SECRET>"))
+      (is (= (:password (d/entity (d/filter db remove-pass) 1) ::not-found) ::not-found))
+      (is (= (:aka (d/entity db 2)) #{"Terrible" "IV"}))
+      (is (= (:aka (d/entity (d/filter db long-akas) 2)) #{"Terrible"})))
+
+    (testing "Index access"
+      (is (= (map :v (d/datoms db :aevt :password))
+             ["<SECRET>" "<PROTECTED>" "<UNKNOWN>"]))
+      (is (= (map :v (d/datoms (d/filter db remove-pass) :aevt :password))
+             [])))
+
+    (testing "equiv"
+      (is (= (d/db-with db [[:db.fn/retractEntity 2]])
+             (d/filter db remove-ivan)))
+      (is (= empty-db
+             (d/filter empty-db (constantly true))
+             (d/filter db (constantly false))))))
+
+  (testing "double filtering"
+    (let [db       (d/db-with (db/empty-db {})
+                              [{:db/id 1, :name "Petr", :age 32}
+                               {:db/id 2, :name "Oleg"}
+                               {:db/id 3, :name "Ivan", :age 12}])
+          has-age? (fn [db datom] (some? (:age (d/entity db (:e datom)))))
+          adult?   (fn [db datom] (>= (:age (d/entity db (:e datom))) 18))
+          names    (fn [db] (map :v (d/datoms db :aevt :name)))]
+      (is (= ["Petr" "Oleg" "Ivan"] (names db)))
+      (is (= ["Petr" "Ivan"]        (names (-> db (d/filter has-age?)))))
+      (is (= ["Petr"]               (names (-> db (d/filter has-age?) (d/filter adult?))))))))

package/test/datahike/test/gc_test.cljc

@@ -0,0 +1,159 @@
+(ns datahike.test.gc-test
+  (:require
+   #?(:cljs [cljs.test :as t :refer-macros [is deftest testing]]
+      :clj  [clojure.test :as t :refer [is deftest testing]])
+   [clojure.set :as set]
+   [superv.async :refer [<?? S]]
+   [datahike.api :as d]
+   [datahike.index.interface :refer [-mark]]
+   [datahike.experimental.versioning :refer [branch! delete-branch! merge!
+                                             branch-history]]
+   [konserve.core :as k]
+   [datahike.test.core-test])
+  (:import [java.util Date]))
+
+#?(:cljs (def Throwable js/Error))
+
+(defn- count-store [db]
+  (count (k/keys (:store db) {:sync? true})))
+
+(def count-query '[:find (count ?e) .
+                   :where
+                   [?e :age _]])
+
+(def txs (vec (for [i (range 1000)] {:age i})))
+
+(def cfg {:store              {:backend :file
+                               :path "/tmp/gc-test"
+                               :id #uuid "9c000000-0000-0000-0000-000000000001"}
+          :keep-history?      true
+          :schema-flexibility :write
+          :index              :datahike.index/persistent-set})
+
+(def schema [{:db/ident       :age
+              :db/cardinality :db.cardinality/one
+              :db/valueType   :db.type/long}])
+
+(deftest datahike-gc-test
+  (let [cfg (assoc-in cfg [:store :path] "/tmp/dh-gc-test")
+        conn (do
+               (d/delete-database cfg)
+               (d/create-database cfg)
+               (d/connect cfg))
+          ;; everything will fit into the root nodes of each index here
+        num-roots 3
+        fresh-count (+ num-roots 4) ;; :branches + :db + cid + roots + schema-meta
+        history-count 3]
+    (testing "Test initial store counts."
+      (is (= 1 (count (-mark (:eavt @conn)))))
+      (is (= fresh-count (count-store @conn)))
+      (d/transact conn schema)
+      (is (= 1 (count (-mark (:eavt @conn)))))
+      (is (= (+ 2 history-count fresh-count num-roots) (count-store @conn))))
+    (testing "Delete old db with roots."
+      (is (= (+ num-roots 2) (count (<?? S (d/gc-storage conn (Date.))))))
+      (is (= (+ history-count fresh-count) (count-store @conn))))
+    (testing "Try to run on dirty index and fail."
+      (is (thrown-with-msg? Throwable #"Index needs to be properly flushed before marking."
+                            (-mark (:eavt
+                                    (:db-after
+                                     (d/with @conn [{:db/id 100
+                                                     :age   5}])))))))
+
+    (testing "Check that we can still read the data."
+      (let [new-conn (d/connect cfg)]
+        (d/transact conn txs)
+        (<?? S (d/gc-storage conn (Date.)))
+        (is (= 1000 (d/q count-query @new-conn)))
+        (d/release new-conn)))
+    (d/release conn)))
+
+(deftest datahike-gc-versioning-test
+  (let [cfg          (assoc-in cfg [:store :path] "/tmp/dh-gc-versioning-test")
+        conn         (do
+                       (d/delete-database cfg)
+                       (d/create-database cfg)
+                       (d/connect cfg))
+        _            (d/transact conn schema)
+        ;; create two more branches
+        _            (branch! conn :db :branch1)
+        cfg1         (assoc cfg :branch :branch1)
+        conn-branch1 (d/connect cfg1)
+        _            (branch! conn :db :branch2)
+        cfg2         (assoc cfg :branch :branch2)
+        conn-branch2 (d/connect cfg2)]
+    (testing "Check branches."
+      (d/transact conn-branch1 txs)
+      (d/transact conn-branch2 txs)
+      (<?? S (d/gc-storage conn (Date.)))
+      (is (nil? (d/q count-query @conn)))
+      (is (= 1000 (d/q count-query @conn-branch1)))
+      (is (= 1000 (d/q count-query @conn-branch2)))
+      (delete-branch! conn :branch2)
+      (<?? S (d/gc-storage conn (Date.))))
+
+    (d/release conn)
+    (d/release conn-branch1)
+    (d/release conn-branch2)
+
+    (testing "Removed branch and after gc check."
+      (let [cfg          (assoc-in cfg [:store :path] "/tmp/dh-gc-versioning-test")
+            conn         (d/connect cfg)
+            ;; create two more branches
+            cfg1         (assoc cfg :branch :branch1)
+            conn-branch1 (d/connect cfg1)
+            cfg2         (assoc cfg :branch :branch2)]
+        (is (nil? (d/q count-query @conn)))
+        (is (= 1000 (d/q count-query @conn-branch1)))
+        (is (thrown-with-msg? Throwable #"Database does not exist."
+                              (d/connect cfg2)))
+        (d/release conn)
+        (d/release conn-branch1)))))
+
+(deftest datahike-gc-range-test
+  (let [cfg           (assoc-in cfg [:store :path] "/tmp/dh-gc-range-test")
+        conn          (do
+                        (d/delete-database cfg)
+                        (d/create-database cfg)
+                        (d/connect cfg))
+        _             (d/transact conn schema)
+        ;; create a branch
+        _             (branch! conn :db :branch1)
+        conn-branch1  (d/connect (assoc cfg :branch :branch1))
+        ;; transact on each
+        _             (d/transact conn txs)
+        _             (d/transact conn-branch1 txs)
+        ;; record before-date for gc
+        _             (Thread/sleep 100)
+        remove-before (Date.)]
+    (Thread/sleep 100)
+    ;; transact
+    (d/transact conn [{:age 42}])
+    (d/transact conn-branch1 [{:age 42}])
+    ;; transact again
+    (d/transact conn [{:age 42}])
+    (d/transact conn-branch1 [{:age 42}])
+    ;; merge back
+    (merge! conn #{:branch1} [])
+    (let [db-history       (<?? S (branch-history conn))
+          branch1-history  (<?? S (branch-history conn-branch1))
+          _ (delete-branch! conn :branch1)
+          _ (testing "Check branch counts"
+              (is (= 9 (count db-history)))
+              (is (= 5 (count branch1-history)))
+              (is (= 9 (count (set/union (set db-history) (set branch1-history))))))
+          new-history      (set (filter (fn [db]
+                                          (let [db-date ^Date (or (get-in db [:meta :datahike/updated-at])
+                                                                  (get-in db [:meta :datahike/created-at]))]
+                                            (> (.getTime db-date)
+                                               (.getTime remove-before))))
+                                        (concat db-history branch1-history)))
+          ;; gc
+          _                (<?? S (d/gc-storage conn remove-before))
+          history-after-gc (set (<?? S (branch-history conn)))]
+      (testing "Check that newer db roots are still there and counts after gc."
+        (is (set/subset? new-history history-after-gc))
+        (is (= 5 (count new-history)))
+        (is (= 7 (count history-after-gc)))))
+    (d/release conn)
+    (d/release conn-branch1)))

package/test/datahike/test/http/server_test.clj

@@ -0,0 +1,192 @@
+(ns datahike.test.http.server-test
+  (:require
+   [clojure.test :as t :refer [is deftest testing]]
+   [datahike.http.server :refer [start-server stop-server]]
+   [datahike.http.client :as api]))
+
+(defn run-server-tests [server-config client-config]
+  (let [{:keys [format]} client-config
+        server (start-server server-config)]
+    (try
+      (let [new-config (api/create-database {:store {:backend :memory :id #uuid "de110000-0000-0000-0000-000000000001"}
+                                             :schema-flexibility :read
+                                             :remote-peer        client-config})
+            _          (is (map? new-config))
+
+            conn                                 (api/connect new-config)
+            {:keys [db-before db-after tx-data]} (api/transact conn [{:name "Peter" :age 42}])
+
+            _ (is (seq tx-data))
+
+            _ (is (not= (:commit-id db-before)
+                        (:commit-id db-after)))
+
+            test-db @conn
+            _       (is (= test-db (api/db conn) db-after))
+
+            query '[:find ?n ?a
+                    :in $
+                    :where
+                    [$ ?e :age ?a]
+                    [$ ?e :name ?n]]
+
+            _ (is (= (api/q query test-db)
+                     #{["Peter" 42]}))
+
+            _ (is (map? (api/query-stats query test-db)))
+
+            _ (is (= (api/pull test-db '[:*] 1)
+                     {:db/id 1, :age 42, :name "Peter"}))
+
+            _ (is (= 3 (count (api/datoms test-db :eavt))))
+
+            _ (is (= 3 (count (api/seek-datoms test-db :eavt))))
+
+            _ (is (map? (api/metrics test-db)))
+
+            _ (is (map? (api/schema test-db)))
+
+            _ (is (map? (api/reverse-schema test-db)))
+
+            _ (is (map? (api/entity test-db 1)))
+
+            _ (when-not (= format :edn)
+                (is (= test-db (api/entity-db (api/entity test-db 1)))))
+
+            _ (is (instance? datahike.remote.RemoteSinceDB (api/since test-db (java.util.Date.))))
+
+            _ (is (instance? datahike.remote.RemoteAsOfDB (api/as-of test-db (java.util.Date.))))
+
+            _ (is (nil? (api/release conn)))
+
+            _ (is (nil? (api/delete-database new-config)))
+
+            _ (is (false? (api/database-exists? new-config)))
+
+            new-config (api/create-database {:store {:backend :memory :id #uuid "de110000-0000-0000-0000-000000000002"}
+                                             :schema-flexibility :write
+                                             :remote-peer        client-config})
+
+            conn (api/connect new-config)
+
+            schema [{:db/ident :name
+                     :db/valueType :db.type/string
+                     :db/cardinality :db.cardinality/one}
+                    {:db/ident :age
+                     :db/valueType :db.type/number
+                     :db/cardinality :db.cardinality/one}]
+
+            _ (api/transact conn schema)
+
+            _ (api/transact conn [{:name "Peter" :age 42}])
+
+            test-db @conn
+            _ (is (= (api/q query test-db)
+                     #{["Peter" 42]}))]
+
+        (is (nil? (api/release conn)))
+        (is (nil? (api/delete-database new-config)))
+        (stop-server server))
+      (finally
+        (stop-server server)))))
+
+(deftest test-server
+  (testing "Test transit binding."
+    (let [port 23189]
+      (run-server-tests {:port     port
+                         :join?    false
+                         :dev-mode false
+                         :token    "securerandompassword"}
+                        {:backend :datahike-server
+                         :url    (str "http://localhost:" port)
+                         :token  "securerandompassword"
+                         :format :transit})))
+  (testing "Test edn binding."
+    (let [port 23190]
+      (run-server-tests {:port     port
+                         :join?    false
+                         :dev-mode false
+                         :token    "securerandompassword"}
+                        {:backend :datahike-server
+                         :url    (str "http://localhost:" port)
+                         :token  "securerandompassword"
+                         :format :edn})))
+  (testing "Test JSON binding."
+    (let [port 23191]
+      (run-server-tests {:port     port
+                         :join?    false
+                         :dev-mode false
+                         :token    "securerandompassword"}
+                        {:backend :datahike-server
+                         :url     (str "http://localhost:" port)
+                         :token   "securerandompassword"
+                         :format  :json}))))
+
+(deftest test-authentication
+  (testing "Password tokens must match."
+    (let [port   23194
+          server (start-server {:port     port
+                                :join?    false
+                                :dev-mode false
+                                :token    "securerandompassword"})]
+      (try
+        (is (thrown-with-msg? Exception #"Exceptional status code: 401"
+                              (api/create-database {:store {:backend :memory :id #uuid "de110000-0000-0000-0000-000000000003"}
+                                                    :schema-flexibility :read
+                                                    :remote-peer        {:backend :datahike-server
+                                                                         :url    (str "http://localhost:" port)
+                                                                         :token  "wrong"
+                                                                         :format :edn}})))
+        (finally
+          (stop-server server)))))
+  (testing "Dev-mode overrides password authentication."
+    (let [port   23195
+          server (start-server {:port     port
+                                :join?    false
+                                :dev-mode true
+                                :token    "securerandompassword"})
+          cfg {:store {:backend :memory :id #uuid "de110000-0000-0000-0000-000000000004"}
+               :schema-flexibility :read
+               :remote-peer        {:backend :datahike-server
+                                    :url    (str "http://localhost:" port)
+                                    :token  "wrong"
+                                    :format :edn}}]
+      (try
+        (api/delete-database cfg)  ; Clean up any existing database
+        (is (map? (api/create-database cfg)))
+        (finally
+          (api/delete-database cfg)
+          (stop-server server))))))
+
+(deftest test-json-interface
+  (testing "Direct JSON interaction"
+    (let [port   23196
+          server (start-server {:port     port
+                                :join?    false
+                                :dev-mode true
+                                :token    "securerandompassword"})
+          remote {:backend :datahike-server
+                  :url     (str "http://localhost:" port)
+                  :token   "securerandompassword"
+                  :format  :json}
+          _ (try (api/request-json-raw :post "delete-database" remote
+                                       "[\"{:store {:backend :memory :id #uuid \\\"23196000-0000-0000-0000-000000000001\\\"}}\"]")
+                 (catch Exception _))]  ; Ignore if database doesn't exist
+      (try
+        (let [raw-cfg  (api/request-json-raw :post "create-database" remote
+                                             "[\"{:store {:backend :memory :id #uuid \\\"23196000-0000-0000-0000-000000000001\\\"} :schema-flexibility :read}\"]")
+              raw-conn (api/request-json-raw :post "connect" remote
+                                             (str "[" raw-cfg "]"))
+              _        (api/request-json-raw :post "transact" remote
+                                             (str "[" raw-conn ", [{\"name\": \"Peter\", \"age\": 42}]]"))
+              raw-db   (api/request-json-raw :post "db" remote
+                                             (str "[" raw-conn "]"))]
+          (is (= (api/request-json-raw :get "q" remote
+                                       (str "[\"[:find ?n ?a :in $1 :where [$1 ?e :age ?a] [$1 ?e :name ?n]]\","
+                                            raw-db "]"))
+                 "[\"!set\",[[\"Peter\",42]]]")))
+        (finally
+          (try (api/request-json-raw :post "delete-database" remote
+                                     "[\"{:store {:backend :memory :id #uuid \\\"23196000-0000-0000-0000-000000000001\\\"}}\"]")
+               (catch Exception _))
+          (stop-server server))))))