datahike-browser-tests 1.0.0

package/test/datahike/test/attribute_refs/pull_api_test.cljc

@@ -0,0 +1,320 @@
+(ns datahike.test.attribute-refs.pull-api-test
+  (:require
+   #?(:cljs [cljs.test :as t :refer-macros [is deftest testing]]
+      :clj  [clojure.test :as t :refer [is deftest testing]])
+   [datahike.test.attribute-refs.utils :refer [ref-db ref-e0 ref-config
+                                               wrap-direct-datoms wrap-ref-datoms]]
+   [datahike.api :as d]))
+
+(def test-direct-datoms
+  [[1 :name  "Petr"]
+   [1 :aka   "Devil"]
+   [1 :aka   "Tupen"]
+   [2 :name  "David"]
+   [3 :name  "Thomas"]
+   [4 :name  "Lucy"]
+   [5 :name  "Elizabeth"]
+   [6 :name  "Matthew"]
+   [7 :name  "Eunan"]
+   [8 :name  "Kerri"]
+   [9 :name  "Rebecca"]
+   [10 :name "Part A"]
+   [11 :name "Part A.A"]
+   [12 :name "Part A.A.A"]
+   [13 :name "Part A.A.A.A"]
+   [14 :name "Part A.A.A.B"]
+   [15 :name "Part A.B"]
+   [16 :name "Part A.B.A"]
+   [17 :name "Part A.B.A.A"]
+   [18 :name "Part A.B.A.B"]])
+
+(def test-ref-datoms
+  [[1 :child 2]
+   [1 :child 3]
+   [2 :father 1]
+   [3 :father 1]
+   [6 :father 3]
+   [10 :part 11]
+   [11 :part 12]
+   [12 :part 13]
+   [12 :part 14]
+   [10 :part 15]
+   [15 :part 16]
+   [16 :part 17]
+   [16 :part 18]])
+
+(defn test-datoms [db offset]
+  (vec (concat (wrap-direct-datoms db offset :db/add  test-direct-datoms)
+               (wrap-ref-datoms db offset :db/add test-ref-datoms))))
+
+(def test-db (d/db-with ref-db (test-datoms ref-db ref-e0)))
+
+(deftest test-pull-attr-spec
+  (is (= {:name "Petr" :aka ["Devil" "Tupen"]}
+         (d/pull test-db '[:name :aka] (+ ref-e0 1))))
+
+  (is (= {:name "Matthew" :father {:db/id (+ ref-e0 3)} :db/id (+ ref-e0 6)}
+         (d/pull test-db '[:name :father :db/id] (+ ref-e0 6))))
+
+  (is (= [{:name "Petr"} {:name "Elizabeth"}
+          {:name "Eunan"} {:name "Rebecca"}]
+         (d/pull-many test-db '[:name]
+                      (mapv (partial + ref-e0) [1 5 7 9])))))
+
+(deftest test-pull-reverse-attr-spec
+  (is (= {:name "David" :_child [{:db/id (+ ref-e0 1)}]}
+         (d/pull test-db '[:name :_child] (+ ref-e0 2))))
+
+  (is (= {:name "David" :_child [{:name "Petr"}]}
+         (d/pull test-db '[:name {:_child [:name]}] (+ ref-e0 2))))
+
+  (testing "Reverse non-component references yield collections"
+    (is (= {:name "Thomas" :_father [{:db/id (+ ref-e0 6)}]}
+           (d/pull test-db '[:name :_father] (+ ref-e0 3))))
+
+    (is (= {:name "Petr" :_father [{:db/id (+ ref-e0 2)} {:db/id (+ ref-e0 3)}]}
+           (d/pull test-db '[:name :_father] (+ ref-e0 1))))
+
+    (is (= {:name "Thomas" :_father [{:name "Matthew"}]}
+           (d/pull test-db '[:name {:_father [:name]}] (+ ref-e0 3))))
+
+    (is (= {:name "Petr" :_father [{:name "David"} {:name "Thomas"}]}
+           (d/pull test-db '[:name {:_father [:name]}] (+ ref-e0 1))))))
+
+(deftest test-pull-component-attr
+  (let [parts {:name "Part A",
+               :part
+               [{:db/id (+ ref-e0 11)
+                 :name "Part A.A",
+                 :part
+                 [{:db/id (+ ref-e0 12)
+                   :name "Part A.A.A",
+                   :part
+                   [{:db/id (+ ref-e0 13) :name "Part A.A.A.A"}
+                    {:db/id (+ ref-e0 14) :name "Part A.A.A.B"}]}]}
+                {:db/id (+ ref-e0 15)
+                 :name "Part A.B",
+                 :part
+                 [{:db/id (+ ref-e0 16)
+                   :name "Part A.B.A",
+                   :part
+                   [{:db/id (+ ref-e0 17) :name "Part A.B.A.A"}
+                    {:db/id (+ ref-e0 18) :name "Part A.B.A.B"}]}]}]}
+        rpart (update-in parts [:part 0 :part 0 :part]
+                         (partial into [{:db/id (+ ref-e0 10)}]))
+        recdb (d/db-with test-db (wrap-ref-datoms test-db ref-e0 :db/add
+                                                  [[12 :part 10]]))]
+
+    (testing "Component entities are expanded recursively"
+      (is (= parts (d/pull test-db '[:name :part] (+ ref-e0 10)))))
+
+    (testing "Reverse component references yield a single result"
+      (is (= {:name "Part A.A" :_part {:db/id (+ ref-e0 10)}}
+             (d/pull test-db [:name :_part] (+ ref-e0 11))))
+
+      (is (= {:name "Part A.A" :_part {:name "Part A"}}
+             (d/pull test-db [:name {:_part [:name]}] (+ ref-e0 11)))))
+
+    (testing "Like explicit recursion, expansion will not allow loops"
+      (is (= rpart (d/pull recdb '[:name :part] (+ ref-e0 10)))))))
+
+(deftest test-pull-wildcard
+  (is (= {:db/id (+ ref-e0 1)
+          :name "Petr"
+          :aka ["Devil" "Tupen"]
+          :child [{:db/id (+ ref-e0 2)} {:db/id (+ ref-e0 3)}]}
+         (d/pull test-db '[*] (+ ref-e0 1))))
+
+  (is (= {:db/id (+ ref-e0 2)
+          :name "David"
+          :_child [{:db/id (+ ref-e0 1)}]
+          :father {:db/id (+ ref-e0 1)}}
+         (d/pull test-db '[* :_child] (+ ref-e0 2)))))
+
+(deftest test-pull-limit
+  (let [db (d/db-with test-db
+                      (concat
+                       (wrap-ref-datoms test-db ref-e0 :db/add
+                                        [[4 :friend 5]
+                                         [4 :friend 6]
+                                         [4 :friend 7]
+                                         [4 :friend 8]])
+                       (wrap-direct-datoms test-db ref-e0 :db/add
+                                           (for [idx (range 2000)]
+                                             [8 :aka (str "aka-" idx)]))))]
+
+    (testing "Without an explicit limit, the default is 1000"
+      (is (= 1000 (->> (d/pull db '[:aka] (+ ref-e0 8)) :aka count))))
+
+    (testing "Explicit limit can reduce the default"
+      (is (= 500 (->> (d/pull db '[(limit :aka 500)] (+ ref-e0 8)) :aka count)))
+      (is (= 500 (->> (d/pull db '[[:aka :limit 500]] (+ ref-e0 8)) :aka count))))
+
+    (testing "Explicit limit can increase the default"
+      (is (= 1500 (->> (d/pull db '[(limit :aka 1500)] (+ ref-e0 8)) :aka count))))
+
+    (testing "A nil limit produces unlimited results"
+      (is (= 2000 (->> (d/pull db '[(limit :aka nil)] (+ ref-e0 8)) :aka count))))
+
+    (testing "Limits can be used as map specification keys"
+      (is (= {:name "Lucy"
+              :friend [{:name "Elizabeth"} {:name "Matthew"}]}
+             (d/pull db '[:name {(limit :friend 2) [:name]}] (+ ref-e0 4)))))))
+
+(deftest test-pull-default
+  (testing "Empty results return nil"
+    (is (nil? (d/pull test-db '[:foo] (+ ref-e0 1)))))
+
+  (testing "A default can be used to replace nil results"
+    (is (= {:foo "bar"}
+           (d/pull test-db '[(default :foo "bar")] (+ ref-e0 1))))
+    (is (= {:foo "bar"}
+           (d/pull test-db '[[:foo :default "bar"]] (+ ref-e0 1))))))
+
+(deftest test-pull-as
+  (is (= {"Name" "Petr", :alias ["Devil" "Tupen"]}
+         (d/pull test-db '[[:name :as "Name"] [:aka :as :alias]] (+ ref-e0 1)))))
+
+(deftest test-pull-attr-with-opts
+  (is (= {"Name" "Nothing"}
+         (d/pull test-db '[[:x :as "Name" :default "Nothing"]] (+ ref-e0 1)))))
+
+(deftest test-pull-map
+  (testing "Single attrs yield a map"
+    (is (= {:name "Matthew" :father {:name "Thomas"}}
+           (d/pull test-db '[:name {:father [:name]}] (+ ref-e0 6)))))
+
+  (testing "Multi attrs yield a collection of maps"
+    (is (= {:name "Petr" :child [{:name "David"}
+                                 {:name "Thomas"}]}
+           (d/pull test-db '[:name {:child [:name]}] (+ ref-e0 1)))))
+
+  (testing "Missing attrs are dropped"
+    (is (= {:name "Petr"}
+           (d/pull test-db '[:name {:father [:name]}] (+ ref-e0 1)))))
+
+  (testing "Non matching results are removed from collections"
+    (is (= {:name "Petr" :child []}
+           (d/pull test-db '[:name {:child [:foo]}] (+ ref-e0 1)))))
+
+  (testing "Map specs can override component expansion"
+    (let [parts {:name "Part A" :part [{:name "Part A.A"} {:name "Part A.B"}]}]
+      (is (= parts
+             (d/pull test-db '[:name {:part [:name]}] (+ ref-e0 10))))
+
+      (is (= parts
+             (d/pull test-db '[:name {:part 1}] (+ ref-e0 10)))))))
+
+(deftest test-pull-recursion
+  (let [irmap (get test-db :ident-ref-map)
+        datoms [[4 :friend 5]
+                [5 :friend 6]
+                [6 :friend 7]
+                [7 :friend 8]
+                [4 :enemy 6]
+                [5 :enemy 7]
+                [6 :enemy 8]
+                [7 :enemy 4]]
+        db (d/db-with test-db (wrap-ref-datoms test-db ref-e0 :db/add datoms))
+        friends {:db/id (+ ref-e0 4)
+                 :name "Lucy"
+                 :friend
+                 [{:db/id (+ ref-e0 5)
+                   :name "Elizabeth"
+                   :friend
+                   [{:db/id (+ ref-e0 6)
+                     :name "Matthew"
+                     :friend
+                     [{:db/id (+ ref-e0 7)
+                       :name "Eunan"
+                       :friend
+                       [{:db/id (+ ref-e0 8)
+                         :name "Kerri"}]}]}]}]}
+        enemies {:db/id (+ ref-e0 4) :name "Lucy"
+                 :friend
+                 [{:db/id (+ ref-e0 5) :name "Elizabeth"
+                   :friend
+                   [{:db/id (+ ref-e0 6) :name "Matthew"
+                     :enemy [{:db/id (+ ref-e0 8) :name "Kerri"}]}]
+                   :enemy
+                   [{:db/id (+ ref-e0 7) :name "Eunan"
+                     :friend
+                     [{:db/id (+ ref-e0 8) :name "Kerri"}]
+                     :enemy
+                     [{:db/id (+ ref-e0 4) :name "Lucy"
+                       :friend [{:db/id (+ ref-e0 5)}]}]}]}]
+                 :enemy
+                 [{:db/id (+ ref-e0 6) :name "Matthew"
+                   :friend
+                   [{:db/id (+ ref-e0 7) :name "Eunan"
+                     :friend
+                     [{:db/id (+ ref-e0 8) :name "Kerri"}]
+                     :enemy [{:db/id (+ ref-e0 4) :name "Lucy"
+                              :friend [{:db/id (+ ref-e0 5) :name "Elizabeth"}]}]}]
+                   :enemy
+                   [{:db/id (+ ref-e0 8) :name "Kerri"}]}]}]
+
+    (testing "Infinite recursion"
+      (is (= friends (d/pull db '[:db/id :name {:friend ...}] (+ ref-e0 4)))))
+
+    (testing "Multiple recursion specs in one pattern"
+      (is (= enemies (d/pull db '[:db/id :name {:friend 2 :enemy 2}] (+ ref-e0 4)))))
+
+    (let [db (d/db-with db [[:db/add (+ ref-e0 8) (:friend irmap) (+ ref-e0 4)]])]
+      (testing "Cycles are handled by returning only the :db/id of entities which have been seen before"
+        (is (= (update-in friends (take 8 (cycle [:friend 0]))
+                          assoc :friend [{:db/id (+ ref-e0 4) :name "Lucy" :friend [{:db/id (+ ref-e0 5)}]}])
+               (d/pull db '[:db/id :name {:friend ...}] (+ ref-e0 4))))))))
+
+(deftest test-dual-recursion
+  (let [_ (d/delete-database ref-config)
+        _ (d/create-database ref-config)
+        conn (d/connect ref-config)
+        schema [{:db/ident :part
+                 :db/cardinality :db.cardinality/one
+                 :db/valueType :db.type/ref}
+                {:db/ident :spec
+                 :db/cardinality :db.cardinality/one
+                 :db/valueType :db.type/ref}]
+        _ (d/transact conn schema)
+        test-e0 (:max-eid @conn)
+        db (d/db-with @conn (wrap-ref-datoms @conn test-e0 :db/add
+                                             [[1 :part 2]
+                                              [2 :part 3]
+                                              [3 :part 1]
+                                              [1 :spec 2]
+                                              [2 :spec 1]]))]
+    (is (= (d/pull db '[:db/id {:part ...} {:spec ...}] (+ test-e0 1))
+           {:db/id (+ test-e0 1),
+            :spec {:db/id (+ test-e0 2)
+                   :spec {:db/id (+ test-e0 1),
+                          :spec {:db/id (+ test-e0 2)}, :part {:db/id (+ test-e0 2)}}
+                   :part {:db/id (+ test-e0 3),
+                          :part {:db/id (+ test-e0 1),
+                                 :spec {:db/id (+ test-e0 2)},
+                                 :part {:db/id (+ test-e0 2)}}}}
+            :part {:db/id (+ test-e0 2)
+                   :spec {:db/id (+ test-e0 1), :spec {:db/id (+ test-e0 2)}, :part {:db/id (+ test-e0 2)}}
+                   :part {:db/id (+ test-e0 3),
+                          :part {:db/id (+ test-e0 1),
+                                 :spec {:db/id (+ test-e0 2)},
+                                 :part {:db/id (+ test-e0 2)}}}}}))
+    (d/release conn)))
+
+(deftest test-deep-recursion
+  (let [start 100
+        depth 1500
+        irmap (get test-db :ident-ref-map)
+        txd   (mapcat
+               (fn [idx]
+                 [[:db/add idx (:name irmap) (str "Person-" idx)]
+                  [:db/add (dec idx) (:friend irmap) idx]])
+               (range (inc start) depth))
+        db    (d/db-with test-db
+                         (concat txd [[:db/add start (:name irmap) (str "Person-" start)]]))
+        pulled (d/pull db '[:name {:friend ...}] start)
+        path   (->> [:friend 0]
+                    (repeat (dec (- depth start)))
+                    (into [] cat))]
+    (is (= (str "Person-" (dec depth))
+           (:name (get-in pulled path))))))

package/test/datahike/test/attribute_refs/query_find_specs_test.cljc

@@ -0,0 +1,59 @@
+(ns datahike.test.attribute-refs.query-find-specs-test
+  (:require
+   #?(:cljs [cljs.test :as t :refer-macros [deftest testing is]]
+      :clj [clojure.test :as t :refer [deftest testing is]])
+   [datahike.test.attribute-refs.utils :refer [ref-db ref-e0
+                                               wrap-direct-datoms]]
+   [datahike.api :as d]))
+
+(def test-db (d/db-with
+              ref-db
+              (wrap-direct-datoms ref-db ref-e0 :db/add
+                                  [[1 :name "Petr"]
+                                   [1 :age 44]
+                                   [2 :name "Ivan"]
+                                   [2 :age 25]
+                                   [3 :name "Sergey"]
+                                   [3 :age 11]])))
+
+(deftest test-find-specs
+  (is (= #{"Ivan" "Petr" "Sergey"}
+         (set (d/q '[:find [?name ...]
+                     :where [_ :name ?name]]
+                   test-db))))
+  (is (= ["Petr" 44]
+         (d/q [:find ['?name '?age] :where
+               [(+ ref-e0 1) :name '?name]
+               [(+ ref-e0 1) :age  '?age]]
+              test-db)))
+  (is (= "Petr"
+         (d/q [:find '?name '. :where
+               [(+ ref-e0 1) :name '?name]]
+              test-db)))
+
+  (testing "Multiple results get cut"
+    (is (contains?
+         #{["Petr" 44] ["Ivan" 25] ["Sergey" 11]}
+         (d/q '[:find [?name ?age]
+                :where [?e :name ?name]
+                [?e :age  ?age]]
+              test-db)))
+    (is (contains?
+         #{"Ivan" "Petr" "Sergey"}
+         (d/q '[:find ?name .
+                :where [_ :name ?name]]
+              test-db))))
+
+  (testing "Aggregates work with find specs"
+    (is (= [3]
+           (d/q '[:find [(count ?name) ...]
+                  :where [_ :name ?name]]
+                test-db)))
+    (is (= [3]
+           (d/q '[:find [(count ?name)]
+                  :where [_ :name ?name]]
+                test-db)))
+    (is (= 3
+           (d/q '[:find (count ?name) .
+                  :where [_ :name ?name]]
+                test-db)))))

package/test/datahike/test/attribute_refs/query_fns_test.cljc

@@ -0,0 +1,130 @@
+(ns datahike.test.attribute_refs.query-fns-test
+  (:require
+   #?(:cljs [cljs.test    :as t :refer-macros [is are deftest testing]]
+      :clj  [clojure.test :as t :refer        [is are deftest testing]])
+   [datahike.core :as d]
+   [datahike.test.attribute-refs.utils :refer [ref-db ref-e0 shift-entities]])
+  #?(:clj
+     (:import [clojure.lang ExceptionInfo])))
+
+(deftest test-query-fns
+  (let [entities [{:db/id 1, :name  "Ivan",  :age   15}
+                  {:db/id 2, :name  "Petr",  :age   22, :height 240, :parent (+ ref-e0 1)}
+                  {:db/id 3, :name  "Slava", :age   37, :parent (+ ref-e0 2)}]
+        db (d/db-with ref-db (shift-entities ref-e0 entities))]
+
+    (testing "get-else"
+      (is (= (d/q '[:find ?age ?height
+                    :where [?e :age ?age]
+                    [(get-else $ ?e :height 300) ?height]] db)
+             #{[15 300] [22 240] [37 300]}))
+
+      (is (thrown-with-msg? ExceptionInfo #"get-else: nil default value is not supported"
+                            (d/q '[:find ?e ?height
+                                   :where [?e :age]
+                                   [(get-else $ ?e :height nil) ?height]] db))))
+
+    (testing "get-some"
+      (is (= #{[:age 15]
+               [:height 240]
+               [:age 37]}
+             (d/q '[:find ?a ?v
+                    :where [?e :name _]
+                    [(get-some $ ?e :height :age) [?a ?v]]] db))))
+
+    (testing "missing?"
+      (is (= #{[15] [37]}
+             (d/q '[:find ?age
+                    :in $
+                    :where [?e :age ?age]
+                    [(missing? $ ?e :height)]] db))))
+
+    (testing "missing? back-ref"
+      (is (= #{[(+ ref-e0 3)]}
+             (d/q '[:find ?e
+                    :in $
+                    :where [?e :age ?age]
+                    [(missing? $ ?e :_parent)]] db))))
+
+    (testing "Built-ins"
+      (is (= #{[(+ ref-e0 1) (+ ref-e0 2)] [(+ ref-e0 1) (+ ref-e0 3)]}
+             (d/q '[:find  ?e1 ?e2
+                    :where [?e1 :age ?a1]
+                    [?e2 :age ?a2]
+                    [(< ?a1 18 ?a2)]] db))))
+
+    (testing "Passing predicate as source"
+      (is (=  #{[(+ ref-e0 2)] [(+ ref-e0 3)]}
+              (d/q '[:find  ?e
+                     :in    $ ?adult
+                     :where [?e :age ?a]
+                     [(?adult ?a)]]
+                   db
+                   #(> % 18)))))
+
+    (testing "Calling a function"
+      (is (=  #{[(+ ref-e0 1) (+ ref-e0 2) (+ ref-e0 3)] [(+ ref-e0 2) (+ ref-e0 1) (+ ref-e0 3)]}
+              (d/q '[:find  ?e1 ?e2 ?e3
+                     :where [?e1 :age ?a1]
+                     [?e2 :age ?a2]
+                     [?e3 :age ?a3]
+                     [(+ ?a1 ?a2) ?a12]
+                     [(= ?a12 ?a3)]]
+                   db))))
+
+    (testing "Two conflicting function values for one binding."
+      (is (= #{}
+             (d/q '[:find  ?n
+                    :where [(identity 1) ?n]
+                    [(identity 2) ?n]]
+                  db))))
+
+    (testing "Destructured conflicting function values for two bindings."
+      (is (= #{}
+             (d/q '[:find  ?n ?x
+                    :where [(identity [3 4]) [?n ?x]]
+                    [(identity [1 2]) [?n ?x]]]
+                  db))))
+
+    (testing "Rule bindings interacting with function binding. (fn, rule)"
+      (is (= #{[2]}
+             (d/q '[:find  ?n
+                    :in $ %
+                    :where [(identity 2) ?n]
+                    (my-vals ?n)]
+                  db
+                  '[[(my-vals ?x)
+                     [(identity 1) ?x]]
+                    [(my-vals ?x)
+                     [(identity 2) ?x]]
+                    [(my-vals ?x)
+                     [(identity 3) ?x]]]))))
+
+    (testing "Rule bindings interacting with function binding. (rule, fn)"
+      (is (= #{[2]}
+             (d/q '[:find  ?n
+                    :in $ %
+                    :where (my-vals ?n)
+                    [(identity 2) ?n]]
+                  db
+                  '[[(my-vals ?x)
+                     [(identity 1) ?x]]
+                    [(my-vals ?x)
+                     [(identity 2) ?x]]
+                    [(my-vals ?x)
+                     [(identity 3) ?x]]]))))
+
+    (testing "Conflicting relational bindings with function binding. (rel, fn)"
+      (is (= #{}
+             (d/q '[:find  ?age
+                    :where [_ :age ?age]
+                    [(identity 100) ?age]]
+                  db))))
+
+    (testing "Conflicting relational bindings with function binding. (fn, rel)"
+      (is (= #{}
+             (d/q '[:find  ?age
+                    :where [(identity 100) ?age]
+                    [_ :age ?age]]
+                  db))))))
+

package/test/datahike/test/attribute_refs/query_interop_test.cljc

@@ -0,0 +1,47 @@
+(ns datahike.test.attribute-refs.query-interop-test
+  (:require
+   #?(:cljs [cljs.test :as t :refer-macros [deftest is are]]
+      :clj [clojure.test :as t :refer [deftest is are]])
+   [datahike.test.attribute-refs.utils :refer [ref-db ref-e0
+                                               wrap-direct-datoms]]
+   [datahike.api :as d]))
+
+#?(:cljs (def Exception js/Error))
+
+(def test-db
+  (d/db-with ref-db
+             (wrap-direct-datoms ref-db ref-e0 :db/add [[1 :name "Vlad"]
+                                                        [2 :name "Ivan"]
+                                                        [3 :name "Sergey"]])))
+
+(deftest test-filter
+  (are [q expected] (= (d/q q test-db) expected)
+    '[:find ?v
+      :where [_ :name ?v]
+      [(.startsWith ?v "Ser")]]
+    #{["Sergey"]}
+
+    '[:find ?v
+      :where [_ :name ?v]
+      [(.contains ?v "a")]]
+    #{["Vlad"] ["Ivan"]}
+
+    '[:find ?v
+      :where [_ :name ?v]
+      [(.matches ?v ".+rg.+")]]
+    #{["Sergey"]}))
+
+(deftest test-bind
+  (are [q expected] (= (d/q q test-db) expected)
+    '[:find ?V
+      :where
+      [?e :name ?v]
+      [(.toLowerCase ?v) ?V]]
+    #{["vlad"] ["ivan"] ["sergey"]}))
+
+(deftest test-method-not-found
+  (is (thrown? Exception (d/q '[:find ?v
+                                :where
+                                [?e :name ?v]
+                                [(.thisMethodDoesNotExist ?v 1)]]
+                              test-db))))