Add closed values related tests

deps.edn

@@ -39,7 +39,7 @@
  :aliases {:cljs {:extra-paths ["src/dev-cljs/" "src/test/" "src/electron/"]
                   :extra-deps  {org.clojure/clojurescript        {:mvn/version "1.11.54"}
                                 org.clojure/tools.namespace      {:mvn/version "0.2.11"}
-                                cider/cider-nrepl                {:mvn/version "0.30.0"}
+                                cider/cider-nrepl                {:mvn/version "0.44.0"}
                                 org.clojars.knubie/cljs-run-test {:mvn/version "1.0.1"}
                                 tortue/spy                       {:mvn/version "2.14.0"}}
                   :main-opts   ["-m" "shadow.cljs.devtools.cli"]}
@@ -50,7 +50,7 @@
                                 pjstadig/humane-test-output      {:mvn/version "0.11.0"}
                                 org.clojars.knubie/cljs-run-test {:mvn/version "1.0.1"}
                                 tortue/spy                       {:mvn/version "2.14.0"}
-                                cider/cider-nrepl                {:mvn/version "0.30.0"}}
+                                cider/cider-nrepl                {:mvn/version "0.44.0"}}
                   :main-opts   ["-m" "shadow.cljs.devtools.cli"]}
 
            :bench {:extra-paths ["src/bench/"]

src/main/frontend/components/property/closed_value.cljs

@@ -133,7 +133,7 @@
         (assoc opts
                :delete-choice
                (fn []
-                 (db-property-handler/delete-closed-value property block)
+                 (db-property-handler/delete-closed-value! property block)
                  (swap! *property-schema update :values (fn [vs] (vec (remove #(= uuid %) vs)))))
                :update-icon
                (fn [icon]

src/main/frontend/handler/db_based/property.cljs

@@ -642,11 +642,13 @@
 
 (defn upsert-closed-value
   "id should be a block UUID or nil"
-  [property {:keys [id value icon description]}]
+  [property {:keys [id value icon description]
+             :or {description ""}}]
   (assert (or (nil? id) (uuid? id)))
   (let [property-type (get-in property [:block/schema :type] :default)]
     (when (contains? db-property-type/closed-value-property-types property-type)
-      (let [value (if (string? value) (string/trim value) value)
+      (let [property (db/entity (:db/id property))
+            value (if (string? value) (string/trim value) value)
             property-schema (:block/schema property)
             closed-values (:values property-schema)
             block-values (map (fn [id] (db/entity [:block/uuid id])) closed-values)
@@ -662,9 +664,6 @@
                               (get (built-in-validation-schemas property {:new-closed-value? true}) property-type)
                               resolved-value)]
         (cond
-          (nil? resolved-value)
-          nil
-
           (some (fn [b] (and (= resolved-value (or (db-pu/property-value-when-closed b)
                                                    (:block/uuid b)))
                              (not= id (:block/uuid b)))) block-values)
@@ -677,6 +676,9 @@
             (notification/show! validate-message :warning)
             :value-invalid)
 
+          (nil? resolved-value)
+          nil
+
           (:block/name value-block)             ; page
           (let [new-values (vec (conj closed-values value))]
             {:block-id value
@@ -762,16 +764,17 @@
                     {:outliner-op :insert-blocks})
       new-value-ids)))
 
-(defn delete-closed-value
-  [property item]
-  (if (seq (:block/_refs item))
+(defn delete-closed-value!
+  [property value-block]
+  (if (seq (:block/_refs value-block))
     (notification/show! "The choice can't be deleted because it's still used." :warning)
-    (let [schema (:block/schema property)
-          tx-data [[:db/retractEntity (:db/id item)]
+    (let [property (db/entity (:db/id property))
+          schema (:block/schema property)
+          tx-data [[:db/retractEntity (:db/id value-block)]
                    {:db/id (:db/id property)
                     :block/schema (update schema :values
                                           (fn [values]
-                                            (vec (remove #{(:block/uuid item)} values))))}]]
+                                            (vec (remove #{(:block/uuid value-block)} values))))}]]
       (db/transact! tx-data))))
 
 (defn get-property-block-created-block

src/test/frontend/handler/db_based/property_test.cljs

@@ -220,13 +220,69 @@
       (is (= 3 (count (:classes-properties
                        (db-property-handler/get-block-classes-properties (:db/id (db/entity [:block/uuid fbid]))))))))))
 
+(defn- get-value-ids
+  [property-name]
+  (:values (:block/schema (db/entity [:block/name property-name]))))
+
+(defn- get-closed-values
+  "Get value from block ids"
+  [values]
+  (set (map #(get-in (db/entity [:block/uuid %]) [:block/schema :value]) values)))
+
 ;; closed values related
 ;; upsert-closed-value
 ;; add-existing-values-to-closed-values!
 ;; delete-closed-value
-;; get-property-block-created-block
+(deftest closed-values-test
+  (testing "Create properties and closed values"
+    (db-property-handler/set-block-property! repo fbid "property-1" "1" {})
+    (db-property-handler/set-block-property! repo sbid "property-1" "2" {})
+    (let [k "property-1"
+          property (db/entity [:block/name k])]
+      (testing "Add existing values to closed values"
+        (db-property-handler/add-existing-values-to-closed-values! property [1 2])
+        (let [values (get-value-ids k)]
+          (is (every? uuid? values))
+          (is (= #{1 2} (get-closed-values values)))
+          (is (every? #(contains? (:block/type (db/entity [:block/uuid %])) "closed value")
+                      values))))
+
+      (testing "Add non-numbers shouldn't work"
+        (let [result (db-property-handler/upsert-closed-value property {:value "not a number"})]
+          (is (= result :value-invalid))
+          (let [values (get-value-ids k)]
+            (is (= #{1 2} (get-closed-values values))))))
+
+      (testing "Add existing value"
+        (let [result (db-property-handler/upsert-closed-value property {:value 2})]
+          (is (= result :value-exists))))
+
+      (testing "Add new value"
+        (let [{:keys [block-id tx-data]} (db-property-handler/upsert-closed-value property {:value 3})]
+          (db/transact! tx-data)
+          (let [b (db/entity [:block/uuid block-id])]
+            (is (= 3 (:value (:block/schema b))))
+            (is (contains? (:block/type b) "closed value")))
+          (let [values (get-value-ids k)]
+            (is (= #{1 2 3} (get-closed-values values))))
+
+          (testing "Update closed value"
+            (let [{:keys [tx-data]} (db-property-handler/upsert-closed-value property {:id block-id
+                                                                                       :value 4
+                                                                                       :description "choice 4"})]
+              (db/transact! tx-data)
+              (let [b (db/entity [:block/uuid block-id])]
+                (is (= 4 (:value (:block/schema b))))
+                (is (= "choice 4" (:description (:block/schema b))))
+                (is (contains? (:block/type b) "closed value")))))
+
+          (testing "Delete closed value"
+            (db-property-handler/delete-closed-value! property (db/entity [:block/uuid block-id]))
+            (is (nil? (db/entity [:block/uuid block-id])))
+            (is (= 2 (count (:values (:block/schema (db/entity [:block/name k]))))))))))))
 
 ;; others
+;; get-property-block-created-block
 ;; property-create-new-block
 ;; convert-property-input-string
 ;; replace-key-with-id