datahike-browser-tests 1.0.0

package/test/datahike/test/http/writer_test.clj

@@ -0,0 +1,86 @@
+(ns datahike.test.http.writer-test
+  (:require
+   [clojure.test :as t :refer [is deftest testing]]
+   [datahike.http.server :refer [start-server stop-server]]
+   [datahike.http.writer]
+   [datahike.api :as d]))
+
+(deftest test-http-writer
+  (testing "Testing distributed datahike.http.writer implementation."
+    (let [port  31283
+          server (start-server {:port     port
+                                :join?    false
+                                :dev-mode false
+                                :token    "securerandompassword"})]
+      (try
+        (let [cfg    {:store              {:backend :file
+                                           :path  "/tmp/distributed_writer"
+                                           :id #uuid "17100000-0000-0000-0000-000000000001"}
+                      :keep-history?      true
+                      :schema-flexibility :read
+                      :writer             {:backend :datahike-server
+                                           :url     (str "http://localhost:" port)
+                                           :token   "securerandompassword"}}
+              conn   (do
+                       (when (d/database-exists? cfg)
+                         (d/delete-database cfg))
+                       (d/create-database cfg)
+                       (d/connect cfg))]
+
+          (d/transact conn [{:name "Alice"
+                             :age  25}])
+          (is (= #{[25 "Alice"]}
+                 (d/q '[:find ?a ?v
+                        :in $ ?a
+                        :where
+                        [?e :name ?v]
+                        [?e :age ?a]]
+                      @conn
+                      25)))
+
+          (d/transact conn [{:name "Peter"
+                             :age  18}])
+          (is (= #{[18 "Peter"]}
+                 (d/q '[:find ?a ?v
+                        :in $ ?a
+                        :where
+                        [?e :name ?v]
+                        [?e :age ?a]]
+                      @conn
+                      18)))
+
+          (d/delete-database cfg))
+        (finally
+          (stop-server server))))))
+
+(deftest test-http-writer-failure-without-server
+  (testing "Db creation fails without writer connection."
+    (let [port   38217
+          cfg    {:store              {:backend :memory :id #uuid "00170000-0000-0000-0000-000000000017"}
+                  :keep-history?      true
+                  :schema-flexibility :read
+                  :writer             {:backend :datahike-server
+                                       :url     (str "http://localhost:" port)
+                                       :token   "securerandompassword"}}]
+      (is (thrown? Exception
+                   (do
+                     (d/delete-database cfg)
+                     (d/create-database cfg)
+                     (d/connect cfg))))))
+  (testing "Transact fails without writer connection."
+    (let [port 38217
+          cfg  {:store              {:backend :memory :id #uuid "00180000-0000-0000-0000-000000000018"}
+                :keep-history?      true
+                :schema-flexibility :read
+                :writer             {:backend :datahike-server
+                                     :url     (str "http://localhost:" port)
+                                     :token   "securerandompassword"}}
+          server-cfg {:store              {:backend :memory :id #uuid "00180000-0000-0000-0000-000000000018"}
+                      :keep-history?      true
+                      :schema-flexibility :read}]
+        ;; make sure the database exists before testing transact
+      (do (d/delete-database server-cfg)
+          (d/create-database server-cfg))
+      (is (thrown? Exception
+                   (d/transact (d/connect cfg)
+                               [{:name "Should fail."}]))))))

package/test/datahike/test/ident_test.cljc

@@ -0,0 +1,32 @@
+(ns datahike.test.ident-test
+  (:require
+   [clojure.test :as t :refer [is deftest]]
+   [datahike.api :as d]
+   [datahike.db :as db]))
+
+(def db
+  (-> (db/empty-db {:ref {:db/valueType :db.type/ref}})
+      (d/db-with [[:db/add 1 :db/ident :ent1]
+                  [:db/add 2 :db/ident :ent2]
+                  [:db/add 2 :ref 1]])))
+
+(deftest test-q
+  (is (= 1 (d/q '[:find ?v .
+                  :where [:ent2 :ref ?v]] db)))
+  (is (= 2 (d/q '[:find ?f .
+                  :where [?f :ref :ent1]] db))))
+
+(deftest test-transact!
+  (let [db' (d/db-with db [[:db/add :ent1 :ref :ent2]])]
+    (is (= 2 (-> (d/entity db' :ent1) :ref :db/id)))))
+
+(deftest test-entity
+  (is (= {:db/ident :ent1}
+         (into {} (d/entity db :ent1)))))
+
+(deftest test-pull
+  (is (= {:db/id 1, :db/ident :ent1}
+         (d/pull db '[*] :ent1))))
+
+#_(user/test-var #'test-transact!)
+#_(t/test-ns 'datahike.test.ident)

package/test/datahike/test/index_test.cljc

@@ -0,0 +1,345 @@
+(ns datahike.test.index-test
+  (:require
+   #?(:cljs [cljs.test    :as t :refer-macros [is deftest testing]]
+      :clj  [clojure.test :as t :refer        [is deftest testing]])
+   [datahike.api :as d]
+   [datahike.constants :refer [e0 tx0 emax txmax]]
+   [datahike.datom :as dd]
+   [datahike.db :as db]
+   [datahike.index :as di]
+   [datahike.index.persistent-set :as pset]
+   [org.replikativ.persistent-sorted-set :as psset]))
+
+(deftest test-datoms
+  (let [dvec #(vector (:e %) (:a %) (:v %))
+        db (-> (db/empty-db {:age {:db/index true}})
+               (d/db-with [[:db/add 1 :name "Petr"]
+                           [:db/add 1 :age 44]
+                           [:db/add 2 :name "Ivan"]
+                           [:db/add 2 :age 25]
+                           [:db/add 3 :name "Sergey"]
+                           [:db/add 3 :age 11]]))]
+    (testing "Main indexes, sort order"
+      (is (= [[1 :age 44]
+              [2 :age 25]
+              [3 :age 11]
+              [1 :name "Petr"]
+              [2 :name "Ivan"]
+              [3 :name "Sergey"]]
+             (map dvec (d/datoms db :aevt))))
+
+      (is (= [[1 :age 44]
+              [1 :name "Petr"]
+              [2 :age 25]
+              [2 :name "Ivan"]
+              [3 :age 11]
+              [3 :name "Sergey"]]
+             (map dvec (d/datoms db :eavt))))
+
+      (is (= [[3 :age 11]
+              [2 :age 25]
+              [1 :age 44]]
+             (map dvec (d/datoms db :avet))))) ;; name non-indexed, excluded from avet
+
+    (testing "Components filtration"
+      (is (= [[1 :age 44]
+              [1 :name "Petr"]]
+             (map dvec (d/datoms db :eavt 1))))
+
+      (is (= [[1 :age 44]]
+             (map dvec (d/datoms db :eavt 1 :age))))
+
+      (is (= [[3 :age 11]
+              [2 :age 25]
+              [1 :age 44]]
+             (map dvec (d/datoms db :avet :age)))))))
+
+(deftest test-seek-datoms
+  (let [dvec #(vector (:e %) (:a %) (:v %))
+        db (-> (db/empty-db {:name {:db/index true}
+                             :age  {:db/index true}})
+               (d/db-with [[:db/add 1 :name "Petr"]
+                           [:db/add 1 :age 44]
+                           [:db/add 2 :name "Ivan"]
+                           [:db/add 2 :age 25]
+                           [:db/add 3 :name "Sergey"]
+                           [:db/add 3 :age 11]]))]
+
+    (testing "Non-termination"
+      (is (= (map dvec (d/seek-datoms db :avet :age 10))
+             [[3 :age 11]
+              [2 :age 25]
+              [1 :age 44]
+              [2 :name "Ivan"]
+              [1 :name "Petr"]
+              [3 :name "Sergey"]])))
+
+    (testing "Closest value lookup"
+      (is (= (map dvec (d/seek-datoms db :avet :name "P"))
+             [[1 :name "Petr"]
+              [3 :name "Sergey"]])))
+
+    (testing "Exact value lookup"
+      (is (= (map dvec (d/seek-datoms db :avet :name "Petr"))
+             [[1 :name "Petr"]
+              [3 :name "Sergey"]])))))
+
+#_(deftest test-rseek-datoms ;; TODO: implement rseek within hitchhiker tree
+    (let [dvec #(vector (:e %) (:a %) (:v %))
+          db (-> (db/empty-db {:name {:db/index true}
+                               :age  {:db/index true}})
+                 (d/db-with [[:db/add 1 :name "Petr"]
+                             [:db/add 1 :age 44]
+                             [:db/add 2 :name "Ivan"]
+                             [:db/add 2 :age 25]
+                             [:db/add 3 :name "Sergey"]
+                             [:db/add 3 :age 11]]))]
+
+      (testing "Non-termination"
+        (is (= (map dvec (d/rseek-datoms db :avet :name "Petr"))
+               [[1 :name "Petr"]
+                [2 :name "Ivan"]
+                [1 :age 44]
+                [2 :age 25]
+                [3 :age 11]])))
+
+      (testing "Closest value lookup"
+        (is (= (map dvec (d/rseek-datoms db :avet :age 26))
+               [[2 :age 25]
+                [3 :age 11]])))
+
+      (testing "Exact value lookup"
+        (is (= (map dvec (d/rseek-datoms db :avet :age 25))
+               [[2 :age 25]
+                [3 :age 11]])))))
+
+(deftest test-index-range
+  (let [dvec #(vector (:e %) (:a %) (:v %))
+        db    (d/db-with
+               (db/empty-db {:name {:db/index true}
+                             :age  {:db/index true}})
+               [{:db/id 1 :name "Ivan"   :age 15}
+                {:db/id 2 :name "Oleg"   :age 20}
+                {:db/id 3 :name "Sergey" :age 7}
+                {:db/id 4 :name "Pavel"  :age 45}
+                {:db/id 5 :name "Petr"   :age 20}])]
+    (is (= (map dvec (d/index-range db {:attrid :name :start "Pe" :end "S"}))
+           [[5 :name "Petr"]]))
+    (is (= (map dvec (d/index-range db {:attrid :name :start "O" :end "Sergey"}))
+           [[2 :name "Oleg"]
+            [4 :name "Pavel"]
+            [5 :name "Petr"]
+            [3 :name "Sergey"]]))
+
+    (is (= (map dvec (d/index-range db {:attrid :name :start nil :end "P"}))
+           [[1 :name "Ivan"]
+            [2 :name "Oleg"]]))
+    (is (= (map dvec (d/index-range db {:attrid :name :start "R" :end nil}))
+           [[3 :name "Sergey"]]))
+    (is (= (map dvec (d/index-range db {:attrid :name :start nil :end nil}))
+           [[1 :name "Ivan"]
+            [2 :name "Oleg"]
+            [4 :name "Pavel"]
+            [5 :name "Petr"]
+            [3 :name "Sergey"]]))
+
+    (is (= (map dvec (d/index-range db {:attrid :age :start 15 :end 20}))
+           [[1 :age 15]
+            [2 :age 20]
+            [5 :age 20]]))
+    (is (= (map dvec (d/index-range db {:attrid :age :start 7 :end 45}))
+           [[3 :age 7]
+            [1 :age 15]
+            [2 :age 20]
+            [5 :age 20]
+            [4 :age 45]]))
+    (is (= (map dvec (d/index-range db {:attrid :age :start 0 :end 100}))
+           [[3 :age 7]
+            [1 :age 15]
+            [2 :age 20]
+            [5 :age 20]
+            [4 :age 45]]))))
+
+(deftest test-slice []
+  (testing "Test index -slice"
+    (let [dvec #(vector (:e %) (:a %) (:v %))
+          db (d/db-with
+              (db/empty-db {:name {:db/index true}
+                            :age  {:db/index true}})
+              [{:db/id 1 :name "Ivan"   :age 15}
+               {:db/id 2 :name "Oleg"   :age 20}
+               {:db/id 3 :name "Sergey" :age 7}
+               {:db/id 4 :name "Pavel"  :age 45}
+               {:db/id 5 :name "Petr"   :age 20}])
+          eavt (:eavt db)
+          aevt (:aevt db)
+          avet (:avet db)]
+
+      (is (= (di/-slice eavt (dd/datom e0 nil nil tx0) (dd/datom emax nil nil txmax) :eavt)
+             (d/datoms db :eavt)))
+      (is (= (map dvec (di/-slice eavt (dd/datom e0 nil nil tx0) (dd/datom 2 nil nil txmax) :eavt))
+             [[1 :age 15]
+              [1 :name "Ivan"]
+              [2 :age 20]
+              [2 :name "Oleg"]]))
+      (is (= (map dvec (di/-slice eavt (dd/datom e0 nil nil tx0) (dd/datom 3 :age 7 txmax) :eavt))
+             [[1 :age 15]
+              [1 :name "Ivan"]
+              [2 :age 20]
+              [2 :name "Oleg"]
+              [3 :age 7]]))
+      (is (= (map dvec (di/-slice eavt (dd/datom e0 :age nil tx0) (dd/datom 3 :name "Timofey" txmax) :eavt))
+             [[1 :age 15]
+              [1 :name "Ivan"]
+              [2 :age 20]
+              [2 :name "Oleg"]
+              [3 :age 7]
+              [3 :name "Sergey"]]))
+      (is (= (map dvec (di/-slice eavt (dd/datom e0 :age nil tx0) (dd/datom 3 :name "Timofey" tx0) :eavt))
+             [[1 :age 15]
+              [1 :name "Ivan"]
+              [2 :age 20]
+              [2 :name "Oleg"]
+              [3 :age 7]
+              [3 :name "Sergey"]]))
+      (is (= (map dvec (di/-slice eavt (dd/datom e0 :age nil tx0) (dd/datom 5 :age nil txmax) :eavt))
+             [[1 :age 15]
+              [1 :name "Ivan"]
+              [2 :age 20]
+              [2 :name "Oleg"]
+              [3 :age 7]
+              [3 :name "Sergey"]
+              [4 :age 45]
+              [4 :name "Pavel"]
+              [5 :age 20]]))
+
+      (is (= (map dvec (di/-slice aevt (dd/datom e0 nil nil tx0) (dd/datom 3 :name "Pavel" txmax) :aevt))
+             [[1 :age 15]
+              [2 :age 20]
+              [3 :age 7]
+              [4 :age 45]
+              [5 :age 20]
+              [1 :name "Ivan"]
+              [2 :name "Oleg"]]))
+      (is (= (map dvec (di/-slice aevt (dd/datom e0 nil nil tx0) (dd/datom 5 :age 18 txmax) :aevt))
+             [[1 :age 15]
+              [2 :age 20]
+              [3 :age 7]
+              [4 :age 45]]))
+      (is (= (map dvec (di/-slice aevt (dd/datom e0 nil nil tx0) (dd/datom 3 :name nil txmax) :aevt))
+             [[1 :age 15]
+              [2 :age 20]
+              [3 :age 7]
+              [4 :age 45]
+              [5 :age 20]
+              [1 :name "Ivan"]
+              [2 :name "Oleg"]
+              [3 :name "Sergey"]]))
+
+      (is (= (map dvec (di/-slice avet (dd/datom e0 nil nil tx0) (dd/datom 3 :age 50 txmax) :avet))
+             [[3 :age 7]
+              [1 :age 15]
+              [2 :age 20]
+              [5 :age 20]
+              [4 :age 45]])))))
+
+(deftest test-upsert-replace-comparators
+  (testing "Replace comparators return 0 for old/new datom pairs"
+    (let [old-datom (dd/datom 1 :name "Ivan" 100 true)
+          new-datom (dd/datom 1 :name "Petr" 101 true)]
+
+      (testing "EAVT replace comparator"
+        (let [cmp (dd/index-type->cmp-replace :eavt)]
+          (is (= 0 (cmp old-datom new-datom))
+              "EAVT replace should compare only (e,a), ignoring v and tx")))
+
+      (testing "AEVT replace comparator"
+        (let [cmp (dd/index-type->cmp-replace :aevt)]
+          (is (= 0 (cmp old-datom new-datom))
+              "AEVT replace should compare only (a,e), ignoring v and tx")))
+
+      (testing "AVET replace comparator"
+        (let [cmp (dd/index-type->cmp-replace :avet)]
+          (is (= 0 (cmp old-datom new-datom))
+              "AVET replace should compare only (a,e), ignoring v and tx - not (a,v)!")))))
+
+  (testing "Upsert operations work correctly when values change"
+    (let [old-datom (dd/datom 1 :age 25 100 true)
+          new-datom (dd/datom 1 :age 26 101 true)]
+
+      (testing "EAVT index upsert"
+        (let [index (psset/sorted-set* {:cmp (dd/index-type->cmp-quick :eavt)})
+              index-with-old (pset/insert index old-datom :eavt)
+              updated (pset/upsert index-with-old new-datom :eavt old-datom)
+              datoms (seq updated)]
+          (is (= 1 (count datoms))
+              "Should have exactly 1 datom after upsert")
+          (is (= new-datom (first datoms))
+              "Should contain the new datom, not the old one")))
+
+      (testing "AEVT index upsert"
+        (let [index (psset/sorted-set* {:cmp (dd/index-type->cmp-quick :aevt)})
+              index-with-old (pset/insert index old-datom :aevt)
+              updated (pset/upsert index-with-old new-datom :aevt old-datom)
+              datoms (seq updated)]
+          (is (= 1 (count datoms))
+              "Should have exactly 1 datom after upsert")
+          (is (= new-datom (first datoms))
+              "Should contain the new datom, not the old one")))
+
+      (testing "AVET index upsert"
+        (let [index (psset/sorted-set* {:cmp (dd/index-type->cmp-quick :avet)})
+              index-with-old (pset/insert index old-datom :avet)
+              updated (pset/upsert index-with-old new-datom :avet old-datom)
+              datoms (seq updated)]
+          (is (= 1 (count datoms))
+              "Should have exactly 1 datom after upsert")
+          (is (= new-datom (first datoms))
+              "Should contain the new datom, not the old one")))))
+
+  (testing "Upsert with different entity IDs does not use replace"
+    (let [datom1 (dd/datom 1 :age 25 100 true)
+          datom2 (dd/datom 2 :age 26 101 true)]
+
+      (testing "AVET index - different entities, same attribute"
+        (let [index (psset/sorted-set* {:cmp (dd/index-type->cmp-quick :avet)})
+              index-with-d1 (pset/insert index datom1 :avet)
+              updated (pset/upsert index-with-d1 datom2 :avet nil)  ; nil old-datom means insert
+              datoms (seq updated)]
+          (is (= 2 (count datoms))
+              "Should have 2 datoms when upserting different entities")
+          (is (some #(= datom1 %) datoms)
+              "Should still contain the first datom")
+          (is (some #(= datom2 %) datoms)
+              "Should also contain the second datom"))))))
+
+(deftest test-avet-upsert-replace-ordering-inconsistency
+  (testing "AVET upsert must handle case where (a,v,e) and (a,e) orderings differ"
+    (let [index (psset/sorted-set* {:cmp (dd/index-type->cmp-quick :avet)})
+          datom-e2-v50 (dd/datom 2 42 50 100 true)
+          datom-e3-v75 (dd/datom 3 42 75 100 true)
+          datom-e1-v100 (dd/datom 1 42 100 100 true)
+          index-with-three (-> index
+                               (pset/insert datom-e2-v50 :avet)
+                               (pset/insert datom-e3-v75 :avet)
+                               (pset/insert datom-e1-v100 :avet))]
+      (is (= 3 (count (seq index-with-three)))
+          "Should have 3 datoms")
+      (is (some #(= datom-e1-v100 %) (seq index-with-three))
+          "Datom [e=1, a=42, v=100] should exist")
+      (is (some #(= datom-e2-v50 %) (seq index-with-three))
+          "Datom [e=2, a=42, v=50] should exist")
+      (is (some #(= datom-e3-v75 %) (seq index-with-three))
+          "Datom [e=3, a=42, v=75] should exist")
+      (let [new-datom-e1-v25 (dd/datom 1 42 25 101 true)
+            updated (pset/upsert index-with-three new-datom-e1-v25 :avet datom-e1-v100)]
+        (is (= 3 (count (seq updated)))
+            "Should still have 3 datoms after upsert")
+        (is (some #(= datom-e2-v50 %) (seq updated))
+            "Datom [e=2, a=42, v=50] should STILL exist after replacing [e=1, a=42, v=100]")
+        (is (some #(= datom-e3-v75 %) (seq updated))
+            "Datom [e=3, a=42, v=75] should STILL exist after replacing [e=1, a=42, v=100]")
+        (is (some #(= new-datom-e1-v25 %) (seq updated))
+            "Datom [e=1, a=42, v=25] should exist after replacement")
+        (is (not (some #(= datom-e1-v100 %) (seq updated)))
+            "Old datom [e=1, a=42, v=100] should NOT exist after replacement")))))

package/test/datahike/test/insert.cljc

@@ -0,0 +1,125 @@
+(ns datahike.test.insert
+  (:require
+   #?(:cljs [cljs.test    :as t :refer-macros [is deftest testing]]
+      :clj  [clojure.test :as t :refer        [is deftest testing]])
+   [datahike.api :as d]))
+
+#?(:cljs
+   (def Throwable js/Error))
+
+;; Test that the second insertion of the same datom does not replace the initial one.
+;; That is similar to Datomic's behaviour.
+
+(defn duplicate-test [config]
+  (when (d/database-exists? config)
+    (d/delete-database config))
+  (let [_      (d/create-database config)
+        conn   (d/connect config)
+        schema [{:db/ident       :block/string
+                 :db/valueType   :db.type/string
+                 :db/cardinality :db.cardinality/one}
+                {:db/ident       :block/children
+                 :db/valueType   :db.type/ref
+                 :db/index       true
+                 :db/cardinality :db.cardinality/many}]
+        _     (d/transact conn schema)
+        _     (d/transact conn [{:db/id 501 :block/string "one"}])
+        _     (d/transact conn [{:db/id 502 :block/children 501}]) ;; First transacton
+        datom-1 (first (d/datoms @conn :eavt 502 :block/children))
+        _     (d/transact conn [{:db/id 502 :block/children 501}]) ;; Second transaction
+        datom-2 (first (d/datoms @conn :eavt 502 :block/children))
+        aevt  (d/datoms @conn :aevt :block/children 502)
+        avet  (d/datoms @conn :avet :block/children 501)]
+    (is (= (.-tx datom-1) (.-tx datom-2)))
+    (is (= datom-1 datom-2))
+
+    (is (= 1 (count aevt)))
+    (is (= datom-1 (first aevt)))
+
+    (is (= 1 (count avet)))
+    (is (= datom-1 (first avet)))
+
+    (d/release conn)
+    (d/delete-database config)))
+
+(deftest duplicate-mem
+  (let [config {:store {:backend :memory :id #uuid "00140000-0000-0000-0000-000000000014"}
+                :schema-flexibility :write}]
+    (duplicate-test config)))
+
+(deftest duplicate-file
+  (let [config {:store {:backend :file :path "/tmp/duplicate" :id #uuid "1a5e0000-0000-0000-0000-000000000001"}
+                :schema-flexibility :write}]
+    (duplicate-test config)))
+
+(defn insert-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       :email
+                 :db/cardinality :db.cardinality/many
+                 :db/valueType   :db.type/string}]
+        _ (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"
+                                   :email  "al@al.com"}]})
+      (is (= 1 (count (d/datoms (d/history @conn) :eavt [:name "Alice"] :email)))))
+    (testing "inserting the exact same datom does not change history"
+      (d/transact conn {:tx-data [{:db/id [:name "Alice"]
+                                   :email "al@al.com"}]})
+      (is (= 1 (count (d/datoms (d/history @conn) :eavt [:name "Alice"] :email)))))
+    (testing "changing the datom value just add the new datom to history"
+      (d/transact conn {:tx-data [{:db/id [:name "Alice"]
+                                   :email "al@eco.com"}]})
+      (is (= 2 (count (d/datoms (d/history @conn) :eavt [:name "Alice"] :email)))))
+    (d/release conn)))
+
+(deftest insert-history-mem
+  (let [config {:store {:backend :memory :id #uuid "00150000-0000-0000-0000-000000000015"}
+                :schema-flexibility :write
+                :keep-history? true}]
+    (insert-history-test config)))
+
+(deftest insert-history-file
+  (let [config {:store {:backend :file :path "/tmp/insert-hist-hht" :id #uuid "1a5e0000-0000-0000-0000-000000000002"}
+                :schema-flexibility :write
+                :keep-history? true}]
+    (insert-history-test config)))
+
+(deftest insert-history-file-with-attr-refs
+  (let [config {:store {:backend :file :path "/tmp/insert-hist-attr-refs" :id #uuid "1a5e0000-0000-0000-0000-000000000003"}
+                :schema-flexibility :write
+                :keep-history? true
+                :attribute-refs? true}]
+    (insert-history-test config)))
+
+(deftest insert-read-handlers
+  (let [config {:store {:backend :file :path "/tmp/insert-read-handlers-9" :id #uuid "1a5e0000-0000-0000-0000-000000000004"}
+                :schema-flexibility :write
+                :keep-history? false}
+        schema [{:db/ident       :block/string
+                 :db/valueType   :db.type/string
+                 :db/cardinality :db.cardinality/one}
+                {:db/ident       :block/children
+                 :db/valueType   :db.type/ref
+                 :db/index       true
+                 :db/cardinality :db.cardinality/many}]
+        _      (d/delete-database config)
+        _      (d/create-database config)
+        conn   (d/connect config)]
+    (d/transact conn schema)
+    (d/transact conn (vec (for [i (range 1000)]
+                            {:db/id (inc i) :block/children (inc i)})))
+    (d/release conn)
+
+    (let [conn (d/connect config)]
+      ;; Would fail if insert read handlers are not present
+      (is (d/datoms @conn :eavt))
+      (d/release conn))
+
+    (d/delete-database config)))

package/test/datahike/test/java_bindings_test.clj

@@ -0,0 +1,6 @@
+(ns datahike.test.java-bindings-test
+  (:require
+   [clojure.test :refer [is deftest]]))
+
+(deftest test-java-bindings
+  (is (datahike.java.DatahikeTest/run)))

package/test/datahike/test/listen_test.cljc

@@ -0,0 +1,41 @@
+(ns datahike.test.listen-test
+  (:require
+   #?(:cljs [cljs.test    :as t :refer-macros [is deftest]]
+      :clj  [clojure.test :as t :refer        [is deftest]])
+   [datahike.api :as d]
+   [datahike.datom :as dd]
+   [datahike.constants :as const]
+   [datahike.test.utils :as du]
+   [datahike.test.core-test]))
+
+(deftest test-listen!
+  (let [conn    (du/setup-db)
+        reports (atom [])]
+    (d/transact conn {:tx-data [[:db/add -1 :name "Alex"]
+                                [:db/add -2 :name "Boris"]]})
+    (d/listen conn :test #(swap! reports conj %))
+    (d/transact conn {:tx-data [[:db/add -1 :name "Dima"]
+                                [:db/add -1 :age 19]
+                                [:db/add -2 :name "Evgeny"]]
+                      :tx-meta {:some-metadata 1}})
+    (d/transact conn {:tx-data [[:db/add -1 :name "Fedor"]
+                                [:db/add 1 :name "Alex2"]         ;; should update
+                                [:db/retract 2 :name "Not Boris"] ;; should be skipped
+                                [:db/retract 4 :name "Evgeny"]]})
+    (d/unlisten conn :test)
+    (d/transact conn {:tx-data [[:db/add -1 :name "Georgy"]]})
+
+    (is (= [(dd/datom (+ const/tx0 2) :some-metadata 1 (+ const/tx0 2) true)
+            (dd/datom 3 :name "Dima"   (+ const/tx0 2) true)
+            (dd/datom 3 :age 19        (+ const/tx0 2) true)
+            (dd/datom 4 :name "Evgeny" (+ const/tx0 2) true)]
+           (rest (:tx-data (first @reports)))))
+    (is (= {:some-metadata 1}
+           (dissoc (:tx-meta (first @reports)) :db/txInstant :db/commitId)))
+    (is (= [(dd/datom 5 :name "Fedor"  (+ const/tx0 3) true)
+            (dd/datom 1 :name "Alex2"  (+ const/tx0 3) true)
+            (dd/datom 4 :name "Evgeny" (+ const/tx0 3) false)]
+           (rest (:tx-data (second @reports)))))
+    (is (= (dissoc (:tx-meta (second @reports)) :db/txInstant :db/commitId)
+           {}))
+    (d/release conn)))