datahike-browser-tests 1.0.0

package/test/datahike/test/upsert_test.cljc

@@ -0,0 +1,363 @@
+(ns datahike.test.upsert-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.impl.entity :as de]
+   [datahike.constants :as const]
+   [datahike.test.core-test :as tdc])
+  (:import [java.util UUID]))
+
+#?(:cljs
+   (def Throwable js/Error))
+
+(deftest test-upsert
+  (let [db (d/db-with (db/empty-db {:name  {:db/unique :db.unique/identity}
+                                    :email {:db/unique :db.unique/identity}})
+                      [{:db/id 1 :name "Ivan" :email "@1"}
+                       {:db/id 2 :name "Petr" :email "@2"}])
+        touched (fn [tx e] (into {} (de/touch (d/entity (:db-after tx) e))))
+        tempids (fn [tx] (dissoc (:tempids tx) :db/current-tx))]
+    (testing "upsert, no tempid"
+      (let [tx (d/with db [{:name "Ivan" :age 35}])]
+        (is (= (touched tx 1)
+               {:name "Ivan" :email "@1" :age 35}))
+        (is (= (tempids tx)
+               {}))))
+
+    (testing "upsert by 2 attrs, no tempid"
+      (let [tx (d/with db [{:name "Ivan" :email "@1" :age 35}])]
+        (is (= (touched tx 1)
+               {:name "Ivan" :email "@1" :age 35}))
+        (is (= (tempids tx)
+               {}))))
+
+    (testing "upsert with tempid"
+      (let [tx (d/with db [{:db/id -1 :name "Ivan" :age 35}])]
+        (is (= (touched tx 1)
+               {:name "Ivan" :email "@1" :age 35}))
+        (is (= (tempids tx)
+               {-1 1}))))
+
+    (testing "upsert with string tempid"
+      (let [tx (d/with db [{:db/id "1" :name "Ivan" :age 35}
+                           [:db/add "2" :name "Oleg"]
+                           [:db/add "2" :email "@2"]])]
+        (is (= (touched tx 1)
+               {:name "Ivan" :email "@1" :age 35}))
+        (is (= (touched tx 2)
+               {:name "Oleg" :email "@2"}))
+        (is (= (tempids tx)
+               {"1" 1
+                "2" 2}))))
+
+    (testing "upsert by 2 attrs with tempid"
+      (let [tx (d/with db [{:db/id -1 :name "Ivan" :email "@1" :age 35}])]
+        (is (= (touched tx 1)
+               {:name "Ivan" :email "@1" :age 35}))
+        (is (= (tempids tx)
+               {-1 1}))))
+
+    (testing "upsert to two entities, resolve to same tempid"
+      (let [tx (d/with db [{:db/id -1 :name "Ivan" :age 35}
+                           {:db/id -1 :name "Ivan" :age 36}])]
+        (is (= (touched tx 1)
+               {:name "Ivan" :email "@1" :age 36}))
+        (is (= (tempids tx)
+               {-1 1}))))
+
+    (testing "upsert to two entities, two tempids"
+      (let [tx (d/with db [{:db/id -1 :name "Ivan" :age 35}
+                           {:db/id -2 :name "Ivan" :age 36}])]
+        (is (= (touched tx 1)
+               {:name "Ivan" :email "@1" :age 36}))
+        (is (= (tempids tx)
+               {-1 1, -2 1}))))
+
+    (testing "upsert with existing id"
+      (let [tx (d/with db [{:db/id 1 :name "Ivan" :age 35}])]
+        (is (= (touched tx 1)
+               {:name "Ivan" :email "@1" :age 35}))
+        (is (= (tempids tx)
+               {}))))
+
+    (testing "upsert by 2 attrs with existing id"
+      (let [tx (d/with db [{:db/id 1 :name "Ivan" :email "@1" :age 35}])]
+        (is (= (touched tx 1)
+               {:name "Ivan" :email "@1" :age 35}))
+        (is (= (tempids tx)
+               {}))))
+
+    (testing "upsert conficts with existing id"
+      (is (thrown-with-msg? Throwable #"Conflicting upsert: \[:name \"Ivan\"\] resolves to 1, but entity already has :db/id 2"
+                            (d/with db [{:db/id 2 :name "Ivan" :age 36}]))))
+
+    (testing "upsert conficts with non-existing id"
+      (is (thrown-with-msg? Throwable #"Conflicting upsert: \[:name \"Ivan\"\] resolves to 1, but entity already has :db/id 3"
+                            (d/with db [{:db/id 3 :name "Ivan" :age 36}]))))
+
+    (testing "upsert by non-existing value resolves as update"
+      (let [tx (d/with db [{:name "Ivan" :email "@3" :age 35}])]
+        (is (= (touched tx 1)
+               {:name "Ivan" :email "@3" :age 35}))
+        (is (= (tempids tx)
+               {}))))
+
+    (testing "upsert by 2 conflicting fields"
+      (is (thrown-with-msg? Throwable #"Conflicting upserts: \[:name \"Ivan\"\] resolves to 1, but \[:email \"@2\"\] resolves to 2"
+                            (d/with db [{:name "Ivan" :email "@2" :age 35}]))))
+
+    (testing "upsert over intermediate db"
+      (let [tx (d/with db [{:name "Igor" :age 35}
+                           {:name "Igor" :age 36}])]
+        (is (= (touched tx 3)
+               {:name "Igor" :age 36}))
+        (is (= (tempids tx)
+               {}))))
+
+    (testing "upsert over intermediate db, tempids"
+      (let [tx (d/with db [{:db/id -1 :name "Igor" :age 35}
+                           {:db/id -1 :name "Igor" :age 36}])]
+        (is (= (touched tx 3)
+               {:name "Igor" :age 36}))
+        (is (= (tempids tx)
+               {-1 3}))))
+
+    (testing "upsert over intermediate db, different tempids"
+      (let [tx (d/with db [{:db/id -1 :name "Igor" :age 35}
+                           {:db/id -2 :name "Igor" :age 36}])]
+        (is (= (touched tx 3)
+               {:name "Igor" :age 36}))
+        (is (= (tempids tx)
+               {-1 3, -2 3}))))
+
+    (testing "upsert and :current-tx conflict"
+      (is (thrown-with-msg? Throwable #"Conflicting upsert: \[:name \"Ivan\"\] resolves to 1, but entity already has :db/id \d+"
+                            (d/with db [{:db/id :db/current-tx :name "Ivan" :age 35}]))))))
+
+(deftest test-redefining-ids
+  (let [db (-> (db/empty-db {:name {:db/unique :db.unique/identity}})
+               (d/db-with [{:db/id -1 :name "Ivan"}]))
+        tx (d/with db [{:db/id -1 :age 35}
+                       {:db/id -1 :name "Ivan" :age 36}])]
+    (is (= #{[1 :age 36] [1 :name "Ivan"]}
+           (tdc/all-datoms (:db-after tx))))
+    (is (= {-1 1, :db/current-tx (+ const/tx0 2)}
+           (:tempids tx))))
+
+  (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 (thrown-with-msg? Throwable #"Conflicting upsert: -1 resolves both to 1 and 2"
+                          (d/with db [{:db/id -1 :name "Ivan" :age 35}
+                                      {:db/id -1 :name "Oleg" :age 36}])))))
+
+;; https://github.com/tonsky/datahike/issues/285
+(deftest test-retries-order
+  (let [db (-> (db/empty-db {:name {:db/unique :db.unique/identity}})
+               (d/db-with [[:db/add -1 :age 42]
+                           [:db/add -2 :likes "Pizza"]
+                           [:db/add -1 :name "Bob"]
+                           [:db/add -2 :name "Bob"]]))]
+    (is (= {:db/id 1, :name "Bob", :likes "Pizza", :age 42}
+           (tdc/entity-map db 1))))
+
+  (let [db (-> (db/empty-db {:name {:db/unique :db.unique/identity}})
+               (d/db-with [[:db/add -1 :age 42]
+                           [:db/add -2 :likes "Pizza"]
+                           [:db/add -2 :name "Bob"]
+                           [:db/add -1 :name "Bob"]]))]
+    (is (= {:db/id 2, :name "Bob", :likes "Pizza", :age 42}
+           (tdc/entity-map db 2)))))
+
+(deftest test-vector-upsert
+  (let [db (-> (db/empty-db {:name {:db/unique :db.unique/identity}})
+               (d/db-with [{:db/id -1, :name "Ivan"}]))]
+    (are [tx res] (= res (tdc/all-datoms (d/db-with db tx)))
+      [[:db/add -1 :name "Ivan"]
+       [:db/add -1 :age 12]]
+      #{[1 :age 12] [1 :name "Ivan"]}
+
+      [[:db/add -1 :age 12]
+       [:db/add -1 :name "Ivan"]]
+      #{[1 :age 12] [1 :name "Ivan"]}))
+
+  (let [db (-> (db/empty-db {:name  {:db/unique :db.unique/identity}})
+               (d/db-with [[:db/add -1 :name "Ivan"]
+                           [:db/add -2 :name "Oleg"]]))]
+    (is (thrown-with-msg? Throwable #"Conflicting upsert: -1 resolves both to 1 and 2"
+                          (d/with db [[:db/add -1 :name "Ivan"]
+                                      [:db/add -1 :age 35]
+                                      [:db/add -1 :name "Oleg"]
+                                      [:db/add -1 :age 36]])))))
+
+(defn temporal-history-test [cfg]
+  (let [schema [{:db/ident       :name
+                 :db/cardinality :db.cardinality/one
+                 :db/index       true
+                 :db/unique      :db.unique/identity
+                 :db/valueType   :db.type/string}
+                {:db/ident       :age
+                 :db/cardinality :db.cardinality/one
+                 :db/valueType   :db.type/long}]
+        _ (d/delete-database cfg)
+        _ (d/create-database cfg)
+        conn (d/connect cfg)]
+    (testing "inserting a new datom creates an entry in history"
+      (d/transact conn {:tx-data schema})
+      (d/transact conn {:tx-data [{:name "Alice"
+                                   :age  25}]})
+      (is (= 1 (count (d/datoms (d/history @conn) :eavt [:name "Alice"] :age)))))
+    (testing "inserting the exact same datom"
+      (d/transact conn {:tx-data [{:db/id [:name "Alice"]
+                                   :age 25}]})
+      (testing " does not change history"
+        (is (= 1 (count (d/datoms (d/history @conn) :eavt [:name "Alice"] :age))))))
+    (testing "changing the datom value increases the history with 2 datoms: the retraction datom and the new value."
+      (d/transact conn {:tx-data [{:db/id [:name "Alice"]
+                                   :age 26}]})
+      (is (= 3 (count (d/datoms (d/history @conn) :eavt [:name "Alice"] :age)))))
+    (d/release conn)))
+
+(deftest temporal-history-mem
+  (let [config {:store {:backend :memory :id #uuid "80000000-0000-0000-0000-000000000008"}
+                :schema-flexibility :write
+                :keep-history? true}]
+    (temporal-history-test config)))
+
+(deftest temporal-history-file
+  (let [config {:store {:backend :file :path "/tmp/temp-hist-hht" :id #uuid "ab5e0000-0000-0000-0000-000000000001"}
+                :schema-flexibility :write
+                :keep-history? true}]
+    (temporal-history-test config)))
+
+(deftest temporal-history-file-with-attr-refs
+  (let [config {:store {:backend :file :path "/tmp/temp-hist-attr-refs" :id #uuid "ab5e0000-0000-0000-0000-000000000002"}
+                :schema-flexibility :write
+                :keep-history? true
+                :attribute-refs? true}]
+    (temporal-history-test config)))
+
+(deftest test-upsert-after-large-coll
+  (let [ascii-ish (map char (concat (range 48 58) (range 65 91) (range 97 123)))
+        file-cfg {:store {:backend :file
+                          :path "/tmp/upsert-large-test"
+                          :id #uuid "ab5e0000-0000-0000-0000-000000000003"}}
+        file-pss-cfg {:store {:backend :file
+                              :index :datahike.index/persistent-set
+                              :path    "/tmp/upsert-large-pss-test"
+                              :id #uuid "ab5e0000-0000-0000-0000-000000000004"}}
+        mem-cfg {:store {:backend :memory
+                         :id #uuid "90000000-0000-0000-0000-000000000009"}}
+        _ (if (d/database-exists? file-cfg)
+            (do
+              (d/delete-database file-cfg)
+              (d/create-database file-cfg))
+            (d/create-database file-cfg))
+        _ (if (d/database-exists? file-pss-cfg)
+            (do
+              (d/delete-database file-pss-cfg)
+              (d/create-database file-pss-cfg))
+            (d/create-database file-pss-cfg))
+        _ (if (d/database-exists? mem-cfg)
+            (do
+              (d/delete-database mem-cfg)
+              (d/create-database mem-cfg))
+            (d/create-database mem-cfg))
+        file-conn (d/connect file-cfg)
+        file-pss-conn (d/connect file-pss-cfg)
+        mem-conn (d/connect mem-cfg)
+        initial-active-count 8
+        inactive-count 5
+        space-taker-count 1000]
+    (letfn [(ident-eid [db ident]
+              (d/q '[:find ?e .
+                     :in $ ?ident
+                     :where [?e :db/ident ?ident]]
+                   db ident))
+            (random-uuid []
+              (UUID/randomUUID))
+            (random-char []
+              (rand-nth ascii-ish))
+            (random-string [length]
+              (apply str (repeatedly length random-char)))
+            (ent-ids [db]
+              (d/q '[:find [?e ...]
+                     :where
+                     [?e :ent/id]]
+                   db))
+            (active-count [db]
+              (d/q '[:find (count ?e) .
+                     :where
+                     [?e :ent/active? true]]
+                   db))
+            (init-data [conn]
+              (d/transact conn {:tx-data [{:db/ident       :ent/id
+                                           :db/valueType   :db.type/uuid
+                                           :db/cardinality :db.cardinality/one
+                                           :db/unique      :db.unique/identity
+                                           :db/doc         "The entity ID."}
+                                          {:db/ident       :ent/active?
+                                           :db/valueType   :db.type/boolean
+                                           :db/cardinality :db.cardinality/one
+                                           :db/doc         "Whether the entity is active."}
+                                          {:db/ident       :meta/space-taker
+                                           :db/valueType   :db.type/string
+                                           :db/cardinality :db.cardinality/one
+                                           :db/doc         "Takes up some space in the db"}]})
+
+              (d/transact conn {:tx-data (map (fn [_]
+                                                {:ent/id (random-uuid)})
+                                              (range initial-active-count))})
+
+              (d/transact conn {:tx-data (map (fn [_]
+                                                {:meta/space-taker (random-string 250)})
+                                              (range space-taker-count))})
+
+              (d/transact conn {:tx-data (map (fn [eid]
+                                                {:db/id      eid
+                                                 :ent/active? true})
+                                              (ent-ids @conn))})
+
+              (d/transact conn {:tx-data (->> (ent-ids @conn)
+                                              sort
+                                              (take inactive-count)
+                                              (map (fn [eid]
+                                                     [:db/add eid :ent/active? false])))}))]
+      (testing "File upsert"
+        (init-data file-conn)
+        (let [cached-db @file-conn
+              fresh-conn (d/connect file-cfg)
+              fresh-db @fresh-conn
+              actual-count (- initial-active-count inactive-count)
+              cached-count (active-count cached-db)
+              fresh-count (active-count fresh-db)]
+          (is (= actual-count cached-count))
+          (is (= cached-count fresh-count))
+          (d/release fresh-conn)))
+      (testing "File pss upsert"
+        (init-data file-pss-conn)
+        (let [cached-db    @file-pss-conn
+              fresh-conn   (d/connect file-pss-cfg)
+              fresh-db     @fresh-conn
+              actual-count (- initial-active-count inactive-count)
+              cached-count (active-count cached-db)
+              fresh-count  (active-count fresh-db)]
+          (is (= actual-count cached-count))
+          (is (= cached-count fresh-count))
+          (d/release fresh-conn)))
+      (testing "Mem upsert"
+        (init-data mem-conn)
+        (let [cached-db @mem-conn
+              fresh-conn (d/connect mem-cfg)
+              fresh-db @fresh-conn
+              actual-count (- initial-active-count inactive-count)
+              cached-count (active-count cached-db)
+              fresh-count (active-count fresh-db)]
+          (is (= actual-count cached-count))
+          (is (= cached-count fresh-count))
+          (d/release fresh-conn))))
+    (d/release file-conn)
+    (d/release file-pss-conn)
+    (d/release mem-conn)))

package/test/datahike/test/utils.cljc

@@ -0,0 +1,110 @@
+(ns datahike.test.utils
+  (:require ;; Load hitchhiker-tree FIRST before datahike.api which loads datahike.index
+   #?(:clj [datahike.index.hitchhiker-tree])
+   [datahike.api :as d]
+   [datahike.tools :as tools])
+  #?(:clj (:import [java.util UUID Date])))
+
+(defn get-all-datoms
+  "Based on Wanderung function `wanderung.datahike/extract-datahike-data`."
+  ([db] (get-all-datoms db identity))
+  ([db final-xform]
+   (let [txs (->> db
+                  (d/q '[:find ?tx ?inst
+                         :in $
+                         :where
+                         [?tx :db/txInstant ?inst]
+                         [(< #inst "1970-01-02" ?inst)]])
+                  (sort-by first))
+         query {:query '[:find ?e ?a ?v ?t ?added
+                         :in $ ?t
+                         :where
+                         [?e ?a ?v ?t ?added]
+                         (not [?e :db/txInstant ?v ?t ?added])]
+                :args [(d/history db)]}]
+     (into []
+           (comp (mapcat
+                  (fn [[tid tinst]]
+                    (->> (d/q (update-in query [:args] conj tid))
+                         (sort-by first)
+                         (into [[tid :db/txInstant tinst tid true]]))))
+                 final-xform)
+           txs))))
+
+(defn unmap-tx-timestamp [[e a _ tx added :as datom]]
+  (if (= a :db/txInstant)
+    [e a :timestamp tx added]
+    datom))
+
+(defn cfg-template
+  "Returning a config template with a random store-id"
+  []
+  {:store {:backend :memory
+           :id #?(:clj (java.util.UUID/randomUUID) :cljs (random-uuid))}
+   :keep-history? true
+   :schema-flexibility :read})
+
+(defn recreate-database [cfg]
+  (d/delete-database cfg)
+  (d/create-database cfg)
+  cfg)
+
+(defn with-connect-fn [cfg body-fn]
+  (let [conn (d/connect cfg)]
+    (try
+      (body-fn conn)
+      (finally
+        (d/release conn)))))
+
+(defmacro with-connect [[conn cfg] & body]
+  `(with-connect-fn ~cfg (fn [~conn] ~@body)))
+
+(defn provide-unique-id [cfg]
+  (assoc-in cfg [:store :id] #?(:clj (UUID/randomUUID)
+                                :cljs (random-uuid))))
+
+(defn setup-db
+  "Setting up a test-db in memory by default.  Deep-merges the passed config into the defaults."
+  ([]
+   (setup-db {}))
+  ([cfg]
+   (setup-db cfg (not (get-in cfg [:store :id]))))
+  ([cfg gen-uuid?]
+   (let [cfg (cond-> (tools/deep-merge (cfg-template) cfg)
+               gen-uuid? (provide-unique-id))]
+     (recreate-database cfg)
+     (d/connect cfg))))
+
+(defn all-true? [c] (every? true? c))
+
+(defn all-eq? [c1 c2] (all-true? (map = c1 c2)))
+
+(defn setup-default-db [config test-data]
+  (recreate-database config)
+  (let [conn (d/connect config)]
+    (d/transact conn test-data)
+    conn))
+
+(defn teardown-db [conn]
+  (d/release conn)
+  (d/delete-database (:config @conn)))
+
+(defn with-db
+  "Test database fixture"
+  ([config f]
+   (with-db config [] f))
+  ([config test-data f]
+   (let [conn (setup-default-db config test-data)]
+     (f)
+     (teardown-db conn))))
+
+(defn sleep [ms]
+  #?(:clj (Thread/sleep ms)
+     :cljs (js/setTimeout (fn []) ms)))
+
+(defn get-time []
+  #?(:clj (.getTime (Date.))
+     :cljs (.getTime (js/Date.))))
+
+(defn conn-id []
+  (str (get-time)))

package/test/datahike/test/validation_test.cljc

@@ -0,0 +1,48 @@
+(ns datahike.test.validation-test
+  (:require
+   #?(:cljs [cljs.test    :as t :refer-macros [is are deftest]]
+      :clj  [clojure.test :as t :refer        [is are deftest]])
+   [datahike.api :as d]
+   [datahike.db :as db]
+   [datahike.test.core-test]))
+
+#?(:cljs
+   (def Throwable js/Error))
+
+(deftest test-with-validation
+  (let [db (db/empty-db {:profile {:db/valueType :db.type/ref}})]
+    (are [tx] (thrown-with-msg? Throwable #"Expected number, string, keyword or lookup ref for :db/id" (d/db-with db tx))
+      [{:db/id #"" :name "Ivan"}])
+
+    (are [tx] (thrown-with-msg? Throwable #"Bad entity attribute" (d/db-with db tx))
+      [[:db/add -1 nil "Ivan"]]
+      [[:db/add -1 17 "Ivan"]]
+      [{:db/id -1 17 "Ivan"}])
+
+    (are [tx] (thrown-with-msg? Throwable #"Cannot store nil as a value" (d/db-with db tx))
+      [[:db/add -1 :name nil]]
+      [{:db/id -1 :name nil}])
+
+    (are [tx] (thrown-with-msg? Throwable #"Expected number or lookup ref for entity id" (d/db-with db tx))
+      [[:db/add nil :name "Ivan"]]
+      [[:db/add {} :name "Ivan"]]
+      [[:db/add -1 :profile #"regexp"]]
+      [{:db/id -1 :profile #"regexp"}])
+
+    (is (thrown-with-msg? Throwable #"Unknown operation" (d/db-with db [["aaa" :name "Ivan"]])))
+    (is (thrown-with-msg? Throwable #"Tempids are allowed in :db/add only" (d/db-with db [[:db/retract -1 :name "Ivan"]])))
+    (is (thrown-with-msg? Throwable #"Bad transaction data" (d/db-with db {:profile "aaa"})))))
+
+(deftest ^:no-spec test-with-validation-caught-by-spec
+  (let [db (db/empty-db {:profile {:db/valueType :db.type/ref}})]
+    (is (thrown-with-msg? Throwable #"Bad entity type at" (d/db-with db [:db/add "aaa" :name "Ivan"])))))
+
+(deftest test-unique
+  (let [db (d/db-with (db/empty-db {:name {:db/unique :db.unique/value}})
+                      [[:db/add 1 :name "Ivan"]
+                       [:db/add 2 :name "Petr"]])]
+    (are [tx] (thrown-with-msg? Throwable #"unique constraint" (d/db-with db tx))
+      [[:db/add 3 :name "Ivan"]]
+      [{:db/add 3 :name "Petr"}])
+    (d/db-with db [[:db/add 3 :name "Igor"]])
+    (d/db-with db [[:db/add 3 :nick "Ivan"]])))

package/test/datahike/test/versioning_test.cljc

@@ -0,0 +1,56 @@
+(ns datahike.test.versioning-test
+  (:require #?(:cljs [cljs.test :as t :refer-macros [is deftest testing]]
+               :clj  [clojure.test :as t :refer [is deftest testing]])
+            [datahike.experimental.versioning :refer
+             [branch-history branch! delete-branch! merge! force-branch! branch-as-db parent-commit-ids
+              commit-id commit-as-db]]
+            [datahike.db.utils :refer [db?]]
+            [datahike.api :as d]
+            [konserve.core :as k]
+            [superv.async :refer [<?? S]]))
+
+(deftest datahike-versioning-test
+  (testing "Testing versioning functionality."
+    (let [cfg {:store              {:backend :file
+                                    :path    "/tmp/dh-versioning-test"
+                                    :id #uuid "1e510000-0000-0000-0000-00000000001e"}
+               :keep-history?      true
+               :schema-flexibility :write
+               :index              :datahike.index/persistent-set}
+          conn (do
+                 (d/delete-database cfg)
+                 (d/create-database cfg)
+                 (d/connect cfg))
+          schema [{:db/ident       :age
+                   :db/cardinality :db.cardinality/one
+                   :db/valueType   :db.type/long}]
+          _ (d/transact conn schema)
+          store (:store @conn)]
+      (testing "Test branching."
+        (branch! conn :db :foo)
+        (is (= (k/get store :branches nil {:sync? true})
+               #{:db :foo})))
+      (testing "Test merging."
+        (let [foo-conn (d/connect (assoc cfg :branch :foo))]
+          (d/transact foo-conn [{:age 42}])
+          ;; extracted data from foo and decide to merge it into :db
+          (merge! conn #{:foo} [{:age 42}])
+          (d/release foo-conn))
+        (is (= 4 (count (<?? S (branch-history conn)))))
+        (is (= 2 (count (parent-commit-ids @conn)))))
+      (testing "Force branch."
+        (force-branch! @conn :foo2 #{:foo})
+        (is (db? (branch-as-db store :foo2))))
+      (testing "Load different references on current db."
+        (is (= (commit-as-db store (commit-id @conn))
+               (branch-as-db store :db)
+               @conn)))
+      (testing "Check branch history."
+        (let [conn-foo2 (d/connect (assoc cfg :branch :foo2))]
+          (is (= 4 (count (<?? S (branch-history conn-foo2)))))
+          (d/release conn-foo2)))
+      (testing "Delete branch."
+        (delete-branch! conn :foo)
+        (is (= (k/get store :branches nil {:sync? true})
+               #{:db :foo2})))
+      (d/release conn))))

package/test/datahike/test.cljc

@@ -0,0 +1,66 @@
+(ns datahike.test
+  (:require
+   #?(:cljs [cljs.test    :as t :refer-macros [is are deftest testing]]
+      :clj  [clojure.test :as t :refer        [is are deftest testing]])
+   #?(:clj [clojure.java.shell :as sh])
+   datahike.test.core-test
+   datahike.test.cache-test
+   datahike.test.components-test
+   datahike.test.config-test
+   datahike.test.db-test
+   datahike.test.entity-test
+   datahike.test.explode-test
+   datahike.test.filter-test
+   datahike.test.ident-test
+   datahike.test.index-test
+   datahike.test.listen-test
+   datahike.test.lookup-refs-test
+   datahike.test.lru-test
+   datahike.test.migrate-test
+   datahike.test.pull-api-test
+   datahike.test.purge-test
+   datahike.test.query-test
+   datahike.test.query-aggregates-test
+   datahike.test.query-find-specs-test
+   datahike.test.query-fns-test
+   datahike.test.query-interop-test
+   datahike.test.query-not-test
+   datahike.test.query-or-test
+   datahike.test.query-pull-test
+   datahike.test.query-rules-test
+   datahike.test.schema-test
+   datahike.test.store-test
+   datahike.test.time-variance-test
+   datahike.test.transact-test
+   datahike.test.tuples-test
+   datahike.test.upsert-test
+   datahike.test.upsert-impl-test
+   datahike.test.validation-test
+   datahike.test.attribute-refs.differences-test
+   datahike.test.attribute-refs.entity-test
+   datahike.test.attribute-refs.pull-api-test
+   datahike.test.attribute-refs.query-test
+   datahike.test.attribute-refs.transact-test
+   datahike.test.attribute-refs.utils
+   datahike.test.middleware.query-test
+   datahike.test.middleware.utils-test))
+
+(defn ^:export test-clj []
+  (datahike.test.core/wrap-res #(t/run-all-tests #"datahike\..*")))
+
+(defn ^:export test-cljs []
+  (datahike.test.core/wrap-res #(t/run-all-tests #"datahike\..*")))
+
+#?(:clj
+   (defn test-node [& args]
+     (let [res (apply sh/sh "node" "test_node.js" args)]
+       (println (:out res))
+       (binding [*out* *err*]
+         (println (:err res)))
+       (System/exit (:exit res)))))
+
+(comment
+
+  (test-clj))
+
+

package/tests.edn

@@ -0,0 +1,24 @@
+#kaocha/v1
+        #meta-merge [{:tests    [{:id          :clj-pss
+                                  :ns-patterns ["datahike.test."]
+                                  :bindings {datahike.config/*default-index* :datahike.index/persistent-set}}
+                                 {:id          :clj-hht
+                                  :ns-patterns ["datahike.test."]
+                                  :bindings {datahike.config/*default-index* :datahike.index/hitchhiker-tree}
+                                  :kaocha.plugin.hooks/pre-load [datahike.index.hitchhiker-tree]}
+                                 {:id          :specs
+                                  :skip-meta   [:no-spec]
+                                  :ns-patterns ["datahike.test."]}
+                                 #_{:id          :cljs
+                                    :type        :kaocha.type/cljs
+                                    :ns-patterns ["datahike.test."]}
+                                 {:id         :norm
+                                  :test-paths ["test/datahike/norm"]}
+                                 {:id         :integration
+                                  :test-paths ["test/datahike/integration_test"]}
+                                 {:id         :kabel
+                                  :test-paths ["test/datahike/kabel"]
+                                  :skip-meta  [:browser]}]
+                      ;; More verbose than the default reporter, and with prettier errors
+                      :reporter kaocha.report/documentation}
+                     #include "tests.user.edn"]