datahike-browser-tests 1.0.0

package/test/datahike/test/components_test.cljc

@@ -0,0 +1,92 @@
+(ns datahike.test.components-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]])
+   [datahike.api :as d]
+   [datahike.db :as db]
+   [datahike.test.core-test :as tdc]
+   [datahike.impl.entity :as de]))
+
+(t/use-fixtures :once tdc/no-namespace-maps)
+
+#?(:cljs
+   (def Throwable js/Error))
+
+(deftest test-components
+  (is (thrown-with-msg? Throwable
+                        #"Bad attribute specification for :profile: \{:db/isComponent true\} should also have \{:db/valueType :db.type/ref\}"
+                        (db/empty-db {:profile {:db/isComponent true}})))
+  (is (thrown-with-msg? Throwable
+                        #"Bad attribute specification for \{:profile \{:db/isComponent \"aaa\"\}\}, expected one of #\{true false\}"
+                        (db/empty-db {:profile {:db/isComponent "aaa" :db/valueType :db.type/ref}})))
+
+  (let [db (d/db-with
+            (db/empty-db {:profile {:db/valueType   :db.type/ref
+                                    :db/isComponent true}})
+            [{:db/id 1 :name "Ivan" :profile 3}
+             {:db/id 3 :email "@3"}
+             {:db/id 4 :email "@4"}])
+        visible #(edn/read-string (pr-str %))
+        touched #(visible (de/touch %))]
+
+    (testing "touch"
+      (is (= (touched (d/entity db 1))
+             {:db/id 1
+              :name "Ivan"
+              :profile {:db/id 3
+                        :email "@3"}}))
+      (is (= (touched (d/entity (d/db-with db [[:db/add 3 :profile 4]]) 1))
+             {:db/id 1
+              :name "Ivan"
+              :profile {:db/id 3
+                        :email "@3"
+                        :profile {:db/id 4
+                                  :email "@4"}}})))
+    (testing "retractEntity"
+      (let [db (d/db-with db [[:db.fn/retractEntity 1]])]
+        (is (= (d/q '[:find ?a ?v :where [1 ?a ?v]] db)
+               #{}))
+        (is (= (d/q '[:find ?a ?v :where [3 ?a ?v]] db)
+               #{}))))
+
+    (testing "retractAttribute"
+      (let [db (d/db-with db [[:db.fn/retractAttribute 1 :profile]])]
+        (is (= (d/q '[:find ?a ?v :where [3 ?a ?v]] db)
+               #{}))))
+
+    (testing "reverse navigation"
+      (is (= (visible (:_profile (d/entity db 3)))
+             {:db/id 1})))))
+
+(deftest test-components-multival
+  (let [db (d/db-with
+            (db/empty-db {:profile {:db/valueType   :db.type/ref
+                                    :db/cardinality :db.cardinality/many
+                                    :db/isComponent true}})
+            [{:db/id 1 :name "Ivan" :profile [3 4]}
+             {:db/id 3 :email "@3"}
+             {:db/id 4 :email "@4"}])
+        visible #(edn/read-string (pr-str %))
+        touched #(visible (de/touch %))]
+
+    (testing "touch"
+      (is (= (touched (d/entity db 1))
+             {:db/id 1
+              :name "Ivan"
+              :profile #{{:db/id 3 :email "@3"}
+                         {:db/id 4 :email "@4"}}})))
+
+    (testing "retractEntity"
+      (let [db (d/db-with db [[:db.fn/retractEntity 1]])]
+        (is (= (d/q '[:find ?a ?v :in $ [?e ...] :where [?e ?a ?v]] db [1 3 4])
+               #{}))))
+
+    (testing "retractAttribute"
+      (let [db (d/db-with db [[:db.fn/retractAttribute 1 :profile]])]
+        (is (= (d/q '[:find ?a ?v :in $ [?e ...] :where [?e ?a ?v]] db [3 4])
+               #{}))))
+
+    (testing "reverse navigation"
+      (is (= (visible (:_profile (d/entity db 3)))
+             {:db/id 1})))))

package/test/datahike/test/config_test.cljc

@@ -0,0 +1,158 @@
+(ns datahike.test.config-test
+  (:require
+   #?(:cljs [cljs.test :as t :refer-macros [is are deftest testing]]
+      :clj [clojure.test :as t :refer [is are deftest testing]])
+   [datahike.config :as c]
+   [datahike.db :as db]
+   [datahike.api :as d]
+   [datahike.index :as di]
+   [datahike.index.hitchhiker-tree :as dih]
+   [datahike.connector :as conn]))
+
+#?(:cljs (def Throwable js/Error))
+
+(deftest int-from-env-test
+  (is (= 1000
+         (c/int-from-env :foo 1000))))
+
+(deftest bool-from-env-test
+  (is (c/bool-from-env :foo true)))
+
+(deftest uri-test
+  (let [mem-uri "datahike:mem://config-test"
+        file-uri "datahike:file:///tmp/config-test"]
+
+    (are [x y] (= x (c/uri->config y))
+      {:backend :memory :host "config-test" :uri mem-uri}
+      mem-uri
+
+      {:backend :file :path "/tmp/config-test" :uri file-uri}
+      file-uri)))
+
+(deftest deprecated-test
+  (let [mem-cfg {:backend :memory
+                 :host "deprecated-test"}
+        file-cfg {:backend :file
+                  :path "/deprecated/test"}
+        default-new-cfg {:attribute-refs? false
+                         :keep-history? true
+                         :initial-tx nil
+                         :index :datahike.index/persistent-set
+                         :index-config {}
+                         :schema-flexibility :write
+                         :crypto-hash? false
+                         :branch :db
+                         :writer c/self-writer
+                         :search-cache-size c/*default-search-cache-size*
+                         :store-cache-size c/*default-store-cache-size*}]
+    (is (= (merge default-new-cfg
+                  {:store {:backend :memory :id #uuid "ec3537bd-3f0d-3719-acd5-40751bbb1012"}})
+           (c/from-deprecated mem-cfg)))
+    (is (= (merge default-new-cfg
+                  {:store {:backend :file
+                           :path "/deprecated/test"
+                           :id #uuid "908d33ed-b562-3301-9a9f-94b961e56f05"}})
+           (c/from-deprecated file-cfg)))))
+
+(deftest load-config-test
+  (testing "configuration defaults"
+    (let [config (c/load-config)]
+      (is (= (merge {:store {:backend :memory}
+                     :attribute-refs? c/*default-attribute-refs?*
+                     :keep-history? c/*default-keep-history?*
+                     :schema-flexibility c/*default-schema-flexibility*
+                     :index c/*default-index*
+                     :crypto-hash? c/*default-crypto-hash?*
+                     :branch c/*default-db-branch*
+                     :writer c/self-writer
+                     :search-cache-size c/*default-search-cache-size*
+                     :store-cache-size c/*default-store-cache-size*}
+                    (when (seq (di/default-index-config c/*default-index*))
+                      {:index-config (di/default-index-config c/*default-index*)}))
+             (update config :store dissoc :id :scope))))))
+
+(deftest core-config-test
+  (testing "Schema on write in core empty database"
+    (is (thrown-with-msg? Throwable
+                          #"Bad entity attribute :name at \{:db/id 1, :name \"Ivan\"\}, not defined in current schema"
+                          (d/db-with (db/empty-db nil {:schema-flexibility :write})
+                                     [{:db/id 1 :name "Ivan" :aka ["IV" "Terrible"]}
+                                      {:db/id 2 :name "Petr" :age 37 :huh? false}])))
+    (is (thrown-with-msg? Throwable
+                          #"Incomplete schema attributes, expected at least :db/valueType, :db/cardinality"
+                          (db/empty-db {:name {:db/cardinality :db.cardinality/one}} {:schema-flexibility :write})))
+    (is (= #{["Alice"]}
+           (let [db (-> (db/empty-db {:name {:db/cardinality :db.cardinality/one :db/valueType :db.type/string}} {:schema-flexibility :write})
+                        (d/db-with  [{:name "Alice"}]))]
+             (d/q '[:find ?n :where [_ :name ?n]] db))))
+    (is (= #{["Alice"]}
+           (let [db (-> (db/empty-db [{:db/ident :name :db/cardinality :db.cardinality/one :db/valueType :db.type/string}]
+                                     {:schema-flexibility :write})
+                        (d/db-with  [{:name "Alice"}]))]
+             (d/q '[:find ?n :where [_ :name ?n]] db))))))
+
+(deftest store-identity-config-test
+  (testing "different configs with equal identities"
+    (let [mem-start  {:store {:backend :memory
+                              :id #uuid "51de0715-1000-0000-0000-000000000001"}}
+          mem-other  {:store {:backend :memory
+                              :id #uuid "a107be12-1de0-7157-0000-000000000001"}}
+          file-start {:store {:backend :file
+                              :path "/tmp/store-identity-test"
+                              :id #uuid "1de07157-0000-0000-0000-000000000001"}}
+          file-index {:index :datahike.index/hitchhiker-tree
+                      :store {:backend :file
+                              :path "/tmp/store-identity-test"
+                              :id #uuid "1de07157-0000-0000-0000-000000000001"}}
+          mem-named  {:name "has-name"
+                      :store {:backend :memory
+                              :id #uuid "51de0715-1000-0000-0000-000000000001"}}
+          mem-same   {:store {:backend :memory
+                              :id #uuid "51de0715-1000-0000-0000-000000000001"
+                              :irrelevant-property true}}]
+      (is (thrown-with-msg? Throwable
+                            #"Store identity mismatch"
+                            (conn/ensure-stored-config-consistency mem-start mem-other)))
+      (is (not= mem-start mem-other))
+      (is (thrown-with-msg? Throwable
+                            #"Configuration does not match stored configuration."
+                            (conn/ensure-stored-config-consistency file-start file-index)))
+      (is (not= file-start file-index))
+      (is (thrown-with-msg? Throwable
+                            #"Store identity mismatch"
+                            (conn/ensure-stored-config-consistency mem-start file-start)))
+      (is (not= mem-start file-start))
+      (is (nil? (conn/ensure-stored-config-consistency mem-start mem-named)))
+      (is (not= mem-start mem-named))
+      (is (nil? (conn/ensure-stored-config-consistency mem-start mem-same)))
+      (is (not= mem-start mem-same))
+      (is (nil? (conn/ensure-stored-config-consistency mem-named mem-same)))
+      (is (not= mem-named mem-same)))))
+
+(deftest store-identity-connection-test
+  (testing "different connections with equal identities"
+    (let [mem-start  {:store {:backend :memory
+                              :id #uuid "51dec000-ec71-0000-0000-000000000001"}}
+          mem-other  {:store {:backend :memory
+                              :id #uuid "a107be12-c000-ec71-0000-000000000001"}}
+          file-start {:store {:backend :file
+                              :path "/tmp/store-connection-test"
+                              :id #uuid "c000ec71-0000-0000-0000-000000000001"}}
+          file-index {:index :datahike.index/hitchhiker-tree
+                      :store {:backend :file
+                              :path "/tmp/store-connection-test"
+                              :id #uuid "c000ec71-0000-0000-0000-000000000001"}}
+          mem-named  {:name "has-name"
+                      :store {:backend :memory
+                              :id #uuid "51dec000-ec71-0000-0000-000000000001"}}
+          mem-same   {:store {:backend :memory
+                              :id #uuid "51dec000-ec71-0000-0000-000000000001"
+                              :irrelevant-property true}}
+          _ (doall (map d/delete-database [mem-start mem-other file-start file-index mem-named mem-same]))]
+      (d/create-database mem-start)
+      (is (= (d/connect mem-start) (d/connect mem-named) (d/connect mem-same)))
+      (d/create-database file-start)
+      (d/connect file-start)
+      (is (thrown-with-msg? Throwable
+                            #"Configuration does not match existing connections."
+                            (d/connect file-index))))))

package/test/datahike/test/core_test.cljc

@@ -0,0 +1,105 @@
+(ns datahike.test.core-test
+  (:require
+   #?(:cljs [cljs.test :as t :refer-macros [is deftest]]
+      :clj [clojure.test :as t :refer [is deftest]])
+   [clojure.walk]
+   [clojure.data]
+   #?(:clj [kaocha.stacktrace])
+   [datahike.core :as dc]
+   [datahike.constants :as const]
+   [datahike.impl.entity :as de]
+   #?(:cljs [datahike.test.cljs])))
+
+#?(:cljs
+   (enable-console-print!))
+
+;; Added special case for printing ex-data of ExceptionInfo
+#?(:cljs
+   (defmethod t/report [::t/default :error] [m]
+     (t/inc-report-counter! :error)
+     (println "\nERROR in" (t/testing-vars-str m))
+     (when (seq (:testing-contexts (t/get-current-env)))
+       (println (t/testing-contexts-str)))
+     (when-let [message (:message m)] (println message))
+     (println "expected:" (pr-str (:expected m)))
+     (print "  actual: ")
+     (let [actual (:actual m)]
+       (cond
+         (instance? ExceptionInfo actual)
+         (println (.-stack actual) "\n" (pr-str (ex-data actual)))
+         (instance? js/Error actual)
+         (println (.-stack actual))
+         :else
+         (prn actual)))))
+
+#?(:cljs (def test-summary (atom nil)))
+#?(:cljs (defmethod t/report [::t/default :end-run-tests] [m]
+           (reset! test-summary (dissoc m :type))))
+
+(defn wrap-res [f]
+  #?(:cljs (do (f) (clj->js @test-summary))
+     :clj (let [res (f)]
+            (when (pos? (+ (:fail res) (:error res)))
+              (System/exit 1)))))
+
+(defn entity-map [db e]
+  (when-let [entity (dc/entity db e)]
+    (->> (assoc (into {} entity) :db/id (:db/id entity))
+         (clojure.walk/prewalk #(if (de/entity? %)
+                                  {:db/id (:db/id %)}
+                                  %)))))
+
+(defn all-datoms [db]
+  (into #{} (map (juxt :e :a :v)) (dc/datoms db :eavt)))
+
+(defn no-namespace-maps [t]
+  (binding [*print-namespace-maps* false]
+    (t)))
+
+;; Filter Kaocha frames from exceptions
+
+#?(:clj
+   (alter-var-root #'kaocha.stacktrace/*stacktrace-filters* (constantly ["java." "clojure." "kaocha." "orchestra."])))
+
+;; Core tests
+
+(deftest test-protocols
+  (let [schema {:aka {:db/cardinality :db.cardinality/many}}
+        db (dc/db-with (dc/empty-db schema)
+                       [{:db/id 1 :name "Ivan" :aka ["IV" "Terrible"]}
+                        {:db/id 2 :name "Petr" :age 37 :huh? false}])]
+    (is (= (dc/empty-db schema)
+           (empty db)))
+    (is (= 6 (count db)))
+    (is (= (set (seq db))
+           #{(dc/datom 1 :aka "IV")
+             (dc/datom 1 :aka "Terrible")
+             (dc/datom 1 :name "Ivan")
+             (dc/datom 2 :age 37)
+             (dc/datom 2 :name "Petr")
+             (dc/datom 2 :huh? false)}))))
+
+(defn- now []
+  #?(:clj  (System/currentTimeMillis)
+     :cljs (.getTime (js/Date.))))
+
+(deftest test-uuid
+  (let [now-ms (loop []
+                 (let [ts (now)]
+                   (if (> (mod ts 1000) 900) ;; sleeping over end of a second
+                     (recur)
+                     ts)))
+        now    (int (/ now-ms 1000))]
+    (is (= (* 1000 now) (dc/squuid-time-millis (dc/squuid))))
+    (is (not= (dc/squuid) (dc/squuid)))
+    (is (= (subs (str (dc/squuid)) 0 8)
+           (subs (str (dc/squuid)) 0 8)))))
+
+(deftest test-diff
+  (is (= [[(dc/datom 1 :b 2) (dc/datom 1 :c 4) (dc/datom 2 :a 1)]
+          [(dc/datom 1 :b 3) (dc/datom 1 :d 5)]
+          [(dc/datom 1 :a 1)]]
+         (clojure.data/diff
+          (dc/db-with (dc/empty-db) [{:a 1 :b 2 :c 4} {:a 1}])
+          (dc/db-with (dc/empty-db) [{:a 1 :b 3 :d 5}])))))
+

package/test/datahike/test/datom_test.cljc

@@ -0,0 +1,44 @@
+(ns datahike.test.datom-test
+  (:require
+   #?(:cljs [cljs.test :as t :refer-macros [is deftest testing]]
+      :clj  [clojure.test :as t :refer [is deftest testing]])
+   [datahike.datom :as d :refer [datom]]))
+
+(deftest datom-impl
+  (let [d (datom 123 :foo/bar "foobar")]
+    (is (= [:e 123]
+           (find d :e)))
+    (is (= {:e 123
+            :a :foo/bar
+            :v "foobar"}
+           (select-keys d [:e :a :v])))
+    (is (= 123 (d :e)))))
+
+(deftest prefix-comparators
+  (testing "Prefix comparators match on e,a,v ignoring tx"
+    (let [d1 (datom 1 :name "Alice" 100)
+          d2 (datom 1 :name "Alice" 200)  ; same e,a,v but different tx
+          d3 (datom 1 :name "Bob" 100)]    ; different v
+
+      (testing "eavt prefix"
+        (is (= 0 (d/cmp-datoms-eavt-prefix d1 d2))
+            "Should match datoms with same e,a,v but different tx")
+        (is (not= 0 (d/cmp-datoms-eavt-prefix d1 d3))
+            "Should not match datoms with different v"))
+
+      (testing "aevt prefix"
+        (is (= 0 (d/cmp-datoms-aevt-prefix d1 d2))
+            "Should match datoms with same a,e,v but different tx")
+        (is (not= 0 (d/cmp-datoms-aevt-prefix d1 d3))
+            "Should not match datoms with different v"))
+
+      (testing "avet prefix"
+        (is (= 0 (d/cmp-datoms-avet-prefix d1 d2))
+            "Should match datoms with same a,v,e but different tx")
+        (is (not= 0 (d/cmp-datoms-avet-prefix d1 d3))
+            "Should not match datoms with different v"))))
+
+  (testing "index-type->cmp-prefix returns correct comparator"
+    (is (= d/cmp-datoms-eavt-prefix (d/index-type->cmp-prefix :eavt)))
+    (is (= d/cmp-datoms-aevt-prefix (d/index-type->cmp-prefix :aevt)))
+    (is (= d/cmp-datoms-avet-prefix (d/index-type->cmp-prefix :avet)))))

package/test/datahike/test/db_test.cljc

@@ -0,0 +1,54 @@
+(ns datahike.test.db-test
+  (:require
+   [clojure.data]
+   #?(: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 :as const]
+   [datahike.test.core-test]
+   [datahike.db :as db #?@(:cljs [:refer-macros [defrecord-updatable]]
+                           :clj  [:refer [defrecord-updatable]])]))
+
+#?(:cljs (def Throwable js/Error))
+
+;; verify that defrecord-updatable works with compiler/core macro configuration
+;; define dummy class which redefines hash, could produce either
+;; compiler or runtime error
+;;
+(defrecord-updatable HashBeef [x]
+  #?@(:cljs [IHash                (-hash  [hb] 0xBEEF)]
+      :clj  [clojure.lang.IHashEq (hasheq [hb] 0xBEEF)]))
+
+(deftest test-defrecord-updatable
+  (is (= 0xBEEF (-> (map->HashBeef {:x :ignored}) hash))))
+
+(deftest test-fn-hash-changes
+  (let [db (d/db-with (db/empty-db)
+                      [{:db/id 1 :name "Konrad"}])
+        r1 (d/db-with db [[:db.fn/retractEntity 1]])
+        r2 (d/db-with db [[:db.fn/retractEntity 1]])]
+    (is (= (hash r1) (hash r2)))))
+
+(deftest test-equiv-db-hash
+  (let [db (d/db-with (db/empty-db)
+                      [{:db/id 1 :name "Konrad"}])
+        r1 (d/db-with db [[:db.fn/retractEntity 1]])]
+    (is (= (hash (db/empty-db)) (hash r1)))))
+
+(deftest empty-db-with-schema
+  (testing "Test old write schema"
+    (is (thrown-with-msg? Throwable
+                          #"Incomplete schema attributes, expected at least :db/valueType, :db/cardinality"
+                          (db/empty-db {:name {:db/cardinality :db.cardinality/many}} {:schema-flexibility :write})))
+    (is (= (merge const/non-ref-implicit-schema
+                  {:name {:db/cardinality :db.cardinality/one :db/valueType :db.type/string}})
+           (:schema (db/empty-db {:name {:db/cardinality :db.cardinality/one
+                                         :db/valueType :db.type/string}}
+                                 {:schema-flexibility :write}))))
+
+    (is (= (merge const/non-ref-implicit-schema
+                  {:name {:db/ident :name :db/cardinality :db.cardinality/one :db/valueType :db.type/string}})
+           (:schema (db/empty-db [{:db/ident :name
+                                   :db/cardinality :db.cardinality/one
+                                   :db/valueType :db.type/string}]
+                                 {:schema-flexibility :write}))))))

package/test/datahike/test/entity_spec_test.cljc

@@ -0,0 +1,159 @@
+(ns datahike.test.entity-spec-test
+  (:require
+   #?(:cljs [cljs.test :as t :refer-macros [is deftest testing]]
+      :clj  [clojure.test :as t :refer [is deftest testing]])
+   [datahike.test.core-test]
+   [datahike.api :as d]))
+
+#?(:cljs (def Throwable js/Error))
+
+(def cfg-template {:store {:backend :memory
+                           :id #uuid "001c0000-0000-0000-0000-00000000001c"}
+                   :keep-history? false
+                   :schema-flexibility :write})
+
+(def schema-template
+  [{:db/ident :account/email
+    :db/valueType :db.type/string
+    :db/unique :db.unique/identity
+    :db/cardinality :db.cardinality/one}
+   {:db/ident :account/balance
+    :db/valueType :db.type/long
+    :db/cardinality :db.cardinality/one}])
+
+(defn setup-db [cfg]
+  (d/delete-database cfg)
+  (d/create-database cfg)
+  (d/connect cfg))
+
+(deftest test-attribute-assertion
+  (let [schema (conj schema-template
+                     {:db/ident :account/guard
+                      :db.entity/attrs [:account/email :account/balance]})
+        valid-account {:account/email "antonia@a.corp"
+                       :account/balance 1000}
+        invalid-account {:account/email "arthur@b.corp"}
+        empty-account {}]
+    (letfn [(tx-with-ensure [conn account]
+              (d/transact conn [(assoc account :db/ensure :account/guard)]))]
+      (testing "with write schema flexibility"
+        (let [cfg (-> cfg-template
+                      (assoc-in [:store :id] #uuid "a77e0000-0000-0000-0000-000000000001")
+                      (assoc :initial-tx schema))
+              conn (setup-db cfg)]
+          (testing "assert valid account"
+            (let [{:keys [db-after]} (tx-with-ensure conn valid-account)]
+              (is (= valid-account (d/pull db-after '[:account/email :account/balance] [:account/email (:account/email valid-account)])))))
+          (testing "assert invalid account"
+            (is (thrown-with-msg? Throwable
+                                  #"Entity 5 missing attributes #\{:account/balance\} of spec :account/guard"
+                                  (tx-with-ensure conn invalid-account))))
+          (testing "assert empty entity"
+            (is (thrown-with-msg? Throwable
+                                  #"Entity 5 missing attributes #\{:account/balance :account/email\} of spec :account/guard"
+                                  (tx-with-ensure conn empty-account))))
+          (d/release conn)))
+      (testing "with read schema flexibility"
+        (let [cfg (-> cfg-template
+                      (assoc :schema-flexibility :read)
+                      (assoc-in [:store :id] #uuid "a77e0000-0000-0000-0000-000000000002")
+                      (assoc :initial-tx schema))
+              conn (setup-db cfg)]
+          (testing "assert valid account"
+            (let [{:keys [db-after]} (tx-with-ensure conn valid-account)]
+              (is (= valid-account (d/pull db-after '[:account/email :account/balance] [:account/email (:account/email valid-account)])))))
+          (testing "assert invalid account"
+            (is (thrown-with-msg? Throwable
+                                  #"Entity 5 missing attributes #\{:account/balance\} of spec :account/guard"
+                                  (tx-with-ensure conn invalid-account))))
+          (testing "assert empty entity"
+            (is (thrown-with-msg? Throwable
+                                  #"Entity 5 missing attributes #\{:account/balance :account/email\} of spec :account/guard"
+                                  (tx-with-ensure conn empty-account))))
+          (d/release conn))))))
+
+(defn is-email? [db eid]
+  ;; email could not exist
+  (if-let [email (:account/email (d/entity db eid))]
+    (seq (re-find #"(^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$)" email))
+    false))
+
+(defn positive-balance? [db eid]
+  ;; balance could not exist
+  (if-let [balance (-> (d/entity db eid) :account/balance)]
+    (< 0 balance)
+    false))
+
+(deftest test-predicate-assertion
+  (let [schema (conj schema-template
+                     {:db/ident :account/guard
+                      :db.entity/preds ['datahike.test.entity-spec-test/is-email? 'datahike.test.entity-spec-test/positive-balance?]})
+        valid-account {:account/email "greta@a.corp"
+                       :account/balance 1000}
+        invalid-account {:account/email "georg"
+                         :account/balance 500}
+        invalid-account-multiple {:account/email "gustav"
+                                  :account/balance -500}
+        empty-account {}
+        cfg (-> cfg-template
+                (assoc-in [:store :id] #uuid "a77e0000-0000-0000-0000-000000000003")
+                (assoc :initial-tx schema))
+        conn (setup-db cfg)]
+    (letfn [(tx-with-ensure [account]
+              (d/transact conn {:tx-data [(assoc account :db/ensure :account/guard)]}))]
+      (testing "assert valid account"
+        (let [{:keys [db-after]} (tx-with-ensure valid-account)]
+          (is (= valid-account (d/pull db-after '[:account/email :account/balance] [:account/email (:account/email valid-account)])))))
+      (testing "assert invalid account with one invalid predicate"
+        (is (thrown-with-msg? Throwable
+                              #"Entity 5 failed predicates #\{datahike.test.entity-spec-test/is-email\?\} of spec :account/guard"
+                              (tx-with-ensure invalid-account))))
+      (testing "assert invalid account with mulitple invalid predicates"
+        (is (thrown-with-msg? Throwable
+                              #"Entity 5 failed predicates #\{datahike.test.entity-spec-test/positive-balance\? datahike.test.entity-spec-test/is-email\?\} of spec :account/guard"
+                              (tx-with-ensure invalid-account-multiple))))
+      (testing "assert empty account"
+        (is (thrown-with-msg? Throwable
+                              #"Entity 5 failed predicates #\{datahike.test.entity-spec-test/positive-balance\? datahike.test.entity-spec-test/is-email\?\} of spec :account/guard"
+                              (tx-with-ensure empty-account)))))
+    (d/release conn)))
+
+(deftest test-attribute-and-predicate-assertion
+  (let [schema (conj schema-template
+                     {:db/ident :account/guard
+                      :db.entity/attrs [:account/email :account/balance]
+                      :db.entity/preds ['datahike.test.entity-spec-test/is-email? 'datahike.test.entity-spec-test/positive-balance?]})
+        valid-account {:account/email "karla@a.corp"
+                       :account/balance 1000}
+        invalid-account-attr {:account/email "konstantin@b.corp"}
+        invalid-account-pred {:account/email "kaspar"
+                              :account/balance 500}
+        invalid-account-pred-multiple {:account/email "katharina"
+                                       :account/balance -500}
+        empty-account {}
+        cfg (-> cfg-template
+                (assoc-in [:store :id] #uuid "a77e0000-0000-0000-0000-000000000004")
+                (assoc :initial-tx schema))
+        conn (setup-db cfg)]
+    (letfn [(tx-with-ensure [account]
+              (d/transact conn {:tx-data [(assoc account :db/ensure :account/guard)]}))]
+      (testing "assert valid account"
+        (let [{:keys [db-after]} (tx-with-ensure valid-account)]
+          (is (= valid-account (d/pull db-after '[:account/email :account/balance] [:account/email (:account/email valid-account)])))))
+      (testing "assert invalid account with missing attributes"
+        (is (thrown-with-msg? Throwable
+                              #"Entity 5 missing attributes #\{:account/balance\} of spec :account/guard"
+                              (tx-with-ensure invalid-account-attr))))
+      (testing "assert invalid account with one invalid predicate"
+        (is (thrown-with-msg? Throwable
+                              #"Entity 5 failed predicates #\{datahike.test.entity-spec-test/is-email\?\} of spec :account/guard"
+                              (tx-with-ensure invalid-account-pred))))
+      (testing "assert invalid account with mulitple invalid predicates"
+        (is (thrown-with-msg? Throwable
+                              #"Entity 5 failed predicates #\{datahike.test.entity-spec-test/positive-balance\? datahike.test.entity-spec-test/is-email\?\} of spec :account/guard"
+                              (tx-with-ensure invalid-account-pred-multiple))))
+      (testing "assert empty account with required attributes precidenting over predicates"
+        (is (thrown-with-msg? Throwable
+                              #"Entity 5 missing attributes #\{:account/balance :account/email\} of spec :account/guard"
+                              (tx-with-ensure empty-account)))))
+    (d/release conn)))