datahike-browser-tests 1.0.0

package/test/datahike/test/array_test.cljc

@@ -0,0 +1,40 @@
+(ns datahike.test.array-test
+  (:require
+   #?(:cljs [cljs.test :as t :refer-macros [is deftest testing]]
+      :clj  [clojure.test :as t :refer [is deftest testing]])
+   [clojure.core :refer [byte-array]]
+   [datahike.array :refer [compare-arrays a= wrap-comparable]]))
+
+(deftest test-array-ordering
+  (testing "Array value indexing support."
+
+    ;; empty arrays
+    (is (zero? (compare-arrays (byte-array []) (byte-array []))))
+
+    ;; ordering is by dimensionality first
+    (is (neg? (compare-arrays (byte-array []) (byte-array [5 2 3 5]))))
+    (is (pos? (compare-arrays (byte-array [5 2 3 5]) (byte-array []))))
+    (is (neg? (compare-arrays (byte-array [5 2 3]) (byte-array [5 2 3 5]))))
+    (is (pos? (compare-arrays (byte-array [5 2 3 5]) (byte-array [5 2 3]))))
+
+    ;; for equal length arrays we do an element-wise comparison
+    (is (zero? (compare-arrays (byte-array [5 2 3 5]) (byte-array [5 2 3 5]))))
+    (is (neg?  (compare-arrays (byte-array [5 2 2 5]) (byte-array [5 2 3 1]))))
+    (is (pos?  (compare-arrays (byte-array [6 2 2 5]) (byte-array [5 2 3 5]))))))
+
+(defn a2= [a b]
+  (= (wrap-comparable a)
+     (wrap-comparable b)))
+
+(deftest test-extended-equality
+  (testing "Testing extended equality with support for arrays."
+    (doseq [cmp [a= a2=]]
+      ;; some Clojure semantics safety checks
+      (is (cmp 0 0))
+      (is (cmp "foo" "foo"))
+      (is (not (cmp "foo" "bar")))
+      (is (cmp [{:a 5} 4 "bar"] [{:a 5} 4 "bar"]))
+      (is (cmp (byte-array [5 2 3])
+               (byte-array [5 2 3])))
+      (is (not (cmp (byte-array [5 2 3])
+                    (byte-array [5 2 4])))))))

package/test/datahike/test/attribute_refs/datoms_test.cljc

@@ -0,0 +1,140 @@
+(ns datahike.test.attribute-refs.datoms-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.db :as db :refer [ref-datoms]]
+   [datahike.test.utils :refer [with-connect provide-unique-id
+                                recreate-database]]))
+
+(def cfg
+  {:store {:backend :memory :id (random-uuid)}
+   :keep-history? true
+   :attribute-refs? true
+   :schema-flexibility :write})
+
+(deftest test-datoms-with-components
+  (with-connect [conn (-> cfg
+                          provide-unique-id
+                          recreate-database)]
+    (d/transact conn [{:db/ident :name
+                       :db/cardinality :db.cardinality/one
+                       :db/index true
+                       :db/valueType :db.type/string}
+                      {:db/ident :age
+                       :db/cardinality :db.cardinality/one
+                       :db/valueType :db.type/long}])
+    (d/transact conn [{:name "Alice"
+                       :age 10}])
+    (let [all-datoms (d/datoms @conn {:index :avet :components []})
+          all-tx-inst-datoms (filter (fn [datom]
+                                       (and (= (:e datom)
+                                               (:tx datom))
+                                            (instance? java.util.Date
+                                                       (:v datom))))
+                                     all-datoms)
+          name-datoms (filter (fn [datom] (= "Alice" (:v datom)))
+                              all-datoms)]
+      (is (= 1 (count name-datoms)))
+      (doseq [datom name-datoms]
+        (is (= [datom]
+               (d/datoms
+                @conn
+                {:index :avet
+                 :components [(:a datom)]})))
+        (is (= [datom]
+               (d/datoms
+                @conn
+                {:index :avet
+                 :components [(:a datom)
+                              (:v datom)]})))
+        (is (= [datom]
+               (d/datoms
+                @conn
+                {:index :avet
+                 :components [(:a datom)
+                              (:v datom)
+                              (:e datom)]})))
+        (is (= [datom]
+               (d/datoms
+                @conn
+                {:index :avet
+                 :components [(:a datom)
+                              (:v datom)
+                              (:e datom)
+                              (:tx datom)]}))))
+
+      (is (= 3 (count all-tx-inst-datoms)))
+      (is (= (set all-tx-inst-datoms)
+             (set (d/datoms @conn {:index :avet
+                                   :components [:db/txInstant]}))))
+      (is (= (set all-tx-inst-datoms)
+             (set (d/datoms @conn {:index :aevt
+                                   :components [:db/txInstant]}))))
+      (doseq [datom all-tx-inst-datoms]
+        (is (= [datom]
+               (d/datoms
+                @conn
+                {:index :avet
+                 :components [:db/txInstant
+                              (:v datom)
+                              (:e datom)]})))
+        (is (= [datom]
+               (d/datoms
+                @conn
+                {:index :avet
+                 :components [:db/txInstant
+                              (:v datom)
+                              (:e datom)
+                              (:tx datom)]})))
+        (is (= [datom]
+               (d/datoms
+                @conn
+                {:index :aevt
+                 :components [:db/txInstant
+                              (:e datom)]})))
+        (is (= [datom]
+               (d/datoms
+                @conn
+                {:index :aevt
+                 :components [:db/txInstant
+                              (:e datom)
+                              (:v datom)]})))
+        (is (= [datom]
+               (d/datoms
+                @conn
+                {:index :aevt
+                 :components [:db/txInstant
+                              (:e datom)
+                              (:v datom)
+                              (:tx datom)]})))))))
+
+(deftest test-distinct-datoms-history-db
+  (with-connect [conn (-> cfg
+                          provide-unique-id
+                          recreate-database)]
+    (is (= 1 (-> @conn
+                 d/history
+                 (d/datoms {:index :aevt
+                            :components [:db/txInstant]
+                            :limit -1})
+                 count)))))
+
+(deftest test-history-datoms-in-empty-db
+  (testing "Datoms in history of empty database"
+    (with-connect [conn (-> cfg
+                            provide-unique-id
+                            recreate-database)]
+      (let [datoms (-> @conn
+                       d/history
+                       (d/datoms {:index :aevt
+                                  :components []
+                                  :limit -1}))
+            ident-datom (some (fn [datom]
+                                (when (and (:a datom) (:e datom)
+                                           (= :db/ident (:v datom)))
+                                  datom))
+                              datoms)]
+        (is (seq datoms))
+        (is (apply distinct? datoms))
+        (is ident-datom)))))

package/test/datahike/test/attribute_refs/db_test.cljc

@@ -0,0 +1,42 @@
+(ns datahike.test.attribute-refs.db-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]))
+
+(def ref-cfg
+  {:store {:backend :memory :id #uuid "00230000-0000-0000-0000-000000000023"}
+   :keep-history? true
+   :attribute-refs? true
+   :schema-flexibility :write
+   :name "attr-refs-test"})
+
+(def name-schema [{:db/ident :name
+                   :db/cardinality :db.cardinality/one
+                   :db/valueType :db.type/string}])
+
+(defn setup-db [cfg]
+  (d/delete-database cfg)
+  (d/create-database cfg)
+  (d/connect cfg))
+
+(deftest test-partial-db
+  (let [conn (setup-db ref-cfg)
+        tx0 (-> (d/transact conn name-schema) :db-after :max-tx)
+        tx1 (-> (d/transact conn [{:name "Peter"}]) :db-after :max-tx)
+        tx2 (-> (d/transact conn [{:name "Maria"}]) :db-after :max-tx)]
+    (testing "AsOfDB"
+      (is (= #{["Peter"] ["Maria"]}
+             (d/q '[:find ?v :where [?e :name ?v]]
+                  (d/as-of @conn tx2))))
+      (is (= #{["Peter"]}
+             (d/q '[:find ?v :where [?e :name ?v]]
+                  (d/as-of @conn tx1)))))
+    (testing "SinceDB"
+      (is (= #{["Maria"] ["Peter"]}
+             (d/q '[:find ?v :where [?e :name ?v]]
+                  (d/since @conn tx0))))
+      (is (= #{["Maria"]}
+             (d/q '[:find  ?v :where [?e :name ?v]]
+                  (d/since @conn tx1)))))
+    (d/release conn)))