mirror of
https://github.com/penpot/penpot.git
synced 2026-11-18 16:12:24 +00:00
* 🐛 Make execute_code wait for save before success * 🐛 Address review feedback on waitForSave Reject with an Error carrying a `code`: save-timeout, rolled-back, save-retrying, or the failure code (save-failed by default). Lower the default timeout from 90s to 60s, leaving room for the 30s layout wait and the code under the MCP tool timeout. When persistence is already in error at the start of the wait, keep the stored failure code, and tell a failure Penpot keeps retrying apart from one that needs the file reopened. Share timeout validation with waitForLayoutUpdate through app.plugins.utils, and make reject-not-valid reject with an Error, which also fixes the string rejections of connectLibrary, restore, remove, pin, export, findVersions and saveVersion. The MCP execute_code handler now waits for the save only when the workspace is ready, like the layout wait, so dashboard calls no longer fail on a save error from an earlier file. Move the waitForSave tests to frontend-tests.plugins, add tests for the error codes, the retrying state and a failure during the wait, and add plugin API suite and MCP handler tests. Update the docs, CHANGELOG and the generated API files. AI-assisted-by: claude-opus-5-5
298 lines
14 KiB
Clojure
298 lines
14 KiB
Clojure
;; This Source Code Form is subject to the terms of the Mozilla Public
|
|
;; License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
;; file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
;;
|
|
;; Copyright (c) KALEIDOS SUBSIDIARY SL
|
|
|
|
(ns frontend-tests.plugins.utils-test
|
|
(:require
|
|
[app.common.files.tokens :as cfo]
|
|
[app.common.schema :as sm]
|
|
[app.plugins.utils :as plugins.utils]
|
|
[app.util.i18n :as i18n]
|
|
[cljs.test :as t :include-macros true]
|
|
[cuerdas.core :as str]))
|
|
|
|
;; The plugin error renderer goes through `tr`, which returns the bare
|
|
;; translation code when no locale data is loaded. Load the strings this
|
|
;; namespace asserts on so the assertions exercise the real rendering.
|
|
(i18n/set-default-translations
|
|
#js {"plugins.validation.message" "Field %s is invalid: %s"
|
|
"plugins.validation.invalid-value" "expected %s, got %s (%s)"
|
|
"plugins.validation.received-value" "got %s (%s)"
|
|
"errors.invalid-data" "Invalid data"
|
|
"errors.field-missing" "Missing field"
|
|
"errors.tokens.empty-input" "Empty input"})
|
|
|
|
;; Access the private flattener for direct testing.
|
|
(def ^:private flatten-error-map @#'plugins.utils/flatten-error-map)
|
|
|
|
(t/deftest test-flatten-error-map-flat-input
|
|
;; Regression test for issue #9417.
|
|
;;
|
|
;; When a malli error path has a single element, `interpret-schema-problem`
|
|
;; produces a flat map. The flattener must pass that through unchanged.
|
|
(let [result (flatten-error-map {:group {:message "must be string"}})]
|
|
(t/is (= [["group" "must be string"]] result))))
|
|
|
|
(t/deftest test-flatten-error-map-nested-input
|
|
;; Regression test for issue #9417.
|
|
;;
|
|
;; When a malli error path has multiple elements, `interpret-schema-problem`
|
|
;; produces a nested map via `(assoc-in acc path …)`. The old plugin
|
|
;; consumer destructured assuming a flat shape, so the nested case rendered
|
|
;; the message text as the field name (`Field message is invalid`) instead
|
|
;; of the real validation reason. The flattener must descend until it finds
|
|
;; a leaf carrying a `:message`.
|
|
(let [explain {:sets {0 {:name {:message "must not be empty"}}}}
|
|
result (set (flatten-error-map explain))]
|
|
(t/is (= #{["sets.0.name" "must not be empty"]} result))))
|
|
|
|
(t/deftest test-flatten-error-map-multiple-fields
|
|
;; Multiple validation problems on the same explain produce multiple
|
|
;; entries, none of which clobber each other.
|
|
(let [explain {:group {:message "must be string"}
|
|
:sets {0 {:message "set not found"}}}
|
|
result (set (flatten-error-map explain))]
|
|
(t/is (= #{["group" "must be string"]
|
|
["sets.0" "set not found"]} result))))
|
|
|
|
(t/deftest test-flatten-error-map-mixed-key-types
|
|
;; Numeric indices (from vector positions in the malli path) must render
|
|
;; cleanly; string keys must also be accepted alongside keywords.
|
|
(let [explain {:items {2 {"label" {:message "invalid label"}}}}
|
|
[[path message]] (flatten-error-map explain)]
|
|
(t/is (= "items.2.label" path))
|
|
(t/is (= "invalid label" message))))
|
|
|
|
(t/deftest test-flatten-error-map-empty
|
|
;; No validation errors -> no output (callers join with ". " and would
|
|
;; otherwise emit an empty string, which is fine).
|
|
(t/is (empty? (flatten-error-map {}))))
|
|
|
|
;; ---------------------------------------------------------------------
|
|
;; Issue #9692 — `handle-error` must surface a useful message instead of a
|
|
;; bare "Value not valid. Code: :error".
|
|
;;
|
|
;; `not-valid` is redefined to capture the rendered message directly, so the
|
|
;; assertions don't depend on `st/state` or the console.
|
|
|
|
(t/deftest test-handle-error-plain-js-error
|
|
;; A plain JS error has no `::sm/explain` and CLJS `ex-data` returns nil, so
|
|
;; the handler must fall back to the error's own message rather than nil.
|
|
(let [captured (atom ::none)]
|
|
(with-redefs [plugins.utils/not-valid (fn [_plugin-id _code value]
|
|
(reset! captured value) nil)]
|
|
((plugins.utils/handle-error #uuid "00000000-0000-0000-0000-000000000000")
|
|
(js/Error. "boom: not a function")))
|
|
(t/is (= "boom: not a function" @captured))))
|
|
|
|
(t/deftest test-handle-error-empty-explain
|
|
;; An explain whose errors don't render any message must not produce an
|
|
;; empty string; the handler falls back to the raw explain.
|
|
(let [captured (atom ::none)
|
|
cause (ex-info "invalid" {:app.common.schema/explain {:errors [] :value 1}})]
|
|
(with-redefs [plugins.utils/not-valid (fn [_plugin-id _code value]
|
|
(reset! captured value) nil)]
|
|
((plugins.utils/handle-error #uuid "00000000-0000-0000-0000-000000000000") cause))
|
|
(t/is (string? @captured))
|
|
(t/is (not= "" @captured))))
|
|
|
|
(t/deftest test-error-messages-empty-returns-nil
|
|
;; `error-messages` returns nil (not "") on an explain with no mappable
|
|
;; errors, so `handle-error` can distinguish "no message" from a real one.
|
|
(t/is (nil? (plugins.utils/error-messages {:errors []}))))
|
|
|
|
;; ---------------------------------------------------------------------
|
|
;; Issue #10072 — schema validation errors must say what was expected and
|
|
;; what was received, instead of collapsing into a generic "Invalid data".
|
|
|
|
(t/deftest test-error-messages-reports-expected-and-received
|
|
(let [explain (sm/explain [:map [:value :string]] {:value 16})
|
|
message (plugins.utils/error-messages explain)]
|
|
(t/is (= "Field value is invalid: expected string, got number (16)" message))))
|
|
|
|
(t/deftest test-error-messages-reports-nested-field-path
|
|
(let [explain (sm/explain [:map [:sets [:vector [:map [:name :string]]]]]
|
|
{:sets [{:name true}]})
|
|
message (plugins.utils/error-messages explain)]
|
|
(t/is (= "Field sets.0.name is invalid: expected string, got boolean (true)" message))))
|
|
|
|
(t/deftest test-error-messages-honors-custom-schema-message
|
|
;; A schema that declares its own `:error/message` must keep it; the
|
|
;; expected/received rendering is only a fallback.
|
|
(let [explain (sm/explain [:map [:value [:string {:error/message "must not be empty"}]]]
|
|
{:value 16})
|
|
message (plugins.utils/error-messages explain)]
|
|
(t/is (= "Field value is invalid: must not be empty" message))))
|
|
|
|
(t/deftest test-error-messages-missing-key
|
|
;; Missing keys keep the "field missing" message: there is no received
|
|
;; value to report.
|
|
(let [explain (sm/explain [:map [:value :string]] {})
|
|
message (plugins.utils/error-messages explain)]
|
|
(t/is (= "Field value is invalid: Missing field" message))))
|
|
|
|
(t/deftest test-error-messages-never-generic
|
|
(let [explain (sm/explain [:map [:value :string]] {:value 16})
|
|
message (plugins.utils/error-messages explain)]
|
|
(t/is (not (str/includes? message "Invalid data")))))
|
|
|
|
(t/deftest test-error-messages-truncates-long-values
|
|
(let [value (apply str (repeat 500 "a"))
|
|
explain (sm/explain [:map [:value :int]] {:value value})
|
|
message (plugins.utils/error-messages explain)]
|
|
(t/is (str/includes? message "got string"))
|
|
(t/is (< (count message) 200))))
|
|
|
|
(t/deftest test-error-messages-unicode-value
|
|
(let [explain (sm/explain [:map [:value :int]] {:value "ñ😀"})
|
|
message (plugins.utils/error-messages explain)]
|
|
(t/is (str/includes? message "ñ😀"))))
|
|
|
|
(t/deftest test-error-messages-collection-value
|
|
(let [explain (sm/explain [:map [:value :string]] {:value [1 2]})
|
|
message (plugins.utils/error-messages explain)]
|
|
(t/is (str/includes? message "got array"))))
|
|
|
|
(defn- proxy? [value] (and (map? value) (contains? value :proxy)))
|
|
|
|
(defn- well-formed?
|
|
"False when the string contains a lone UTF-16 surrogate."
|
|
[s]
|
|
(try
|
|
(js/encodeURIComponent s)
|
|
true
|
|
(catch :default _ false)))
|
|
|
|
(t/deftest test-error-messages-union-reports-every-branch
|
|
;; Malli emits one problem per `:or` branch, all sharing the same path.
|
|
;; Reporting a single branch as if it were the only requirement is worse
|
|
;; than saying nothing: `plugins.tokens` declares the token value setter
|
|
;; as `[:or :string base]`, so a plugin author would be told a vector is
|
|
;; required when a plain string is equally valid.
|
|
(let [explain (sm/explain [:map [:value [:or [:vector :string] :string]]] {:value 16})
|
|
message (plugins.utils/error-messages explain)]
|
|
(t/is (= "Field value is invalid: expected [:vector :string] or string, got number (16)"
|
|
message))))
|
|
|
|
(t/deftest test-error-messages-union-reports-every-branch-nested
|
|
(let [explain (sm/explain [:map [:sets [:vector [:or :string :int]]]] {:sets [true]})
|
|
message (plugins.utils/error-messages explain)]
|
|
(t/is (= "Field sets.0 is invalid: expected string or int, got boolean (true)"
|
|
message))))
|
|
|
|
(t/deftest test-error-messages-never-leaks-function-objects
|
|
;; `[:fn pred]` schemas (used by the token-set arguments) render their form
|
|
;; as `#object[app$plugins$tokens$token_set_proxy_QMARK_]`. That must never
|
|
;; reach a plugin author.
|
|
(let [explain (sm/explain [:map [:value [:or [:fn proxy?] :string]]] {:value 16})
|
|
message (plugins.utils/error-messages explain)]
|
|
(t/is (not (str/includes? message "#object")))
|
|
(t/is (= "Field value is invalid: got number (16)" message))))
|
|
|
|
(t/deftest test-error-messages-function-schema-falls-back-to-custom-message
|
|
;; When one branch of the union carries its own message, that message wins
|
|
;; over the un-renderable `[:fn …]` branch.
|
|
(let [explain (sm/explain [:map [:value [:or [:fn proxy?] ::sm/uuid]]] {:value "nope"})
|
|
message (plugins.utils/error-messages explain)]
|
|
(t/is (not (str/includes? message "#object")))
|
|
(t/is (= "Field value is invalid: should be an uuid" message))))
|
|
|
|
(t/deftest test-error-messages-truncation-keeps-surrogate-pairs
|
|
;; Truncating at a UTF-16 code-unit boundary splits astral characters and
|
|
;; produces mojibake in a message whose whole purpose is legibility.
|
|
(let [value (apply str (repeat 200 "😀"))
|
|
explain (sm/explain [:map [:value :int]] {:value value})
|
|
message (plugins.utils/error-messages explain)]
|
|
(t/is (well-formed? message))
|
|
(t/is (str/includes? message "…"))))
|
|
|
|
(t/deftest test-error-messages-truncation-counts-code-points
|
|
;; 60 emoji are 120 UTF-16 code units but only 60 code points: below the
|
|
;; limit, so the value must be reported whole.
|
|
(let [value (apply str (repeat 60 "😀"))
|
|
explain (sm/explain [:map [:value :int]] {:value value})
|
|
message (plugins.utils/error-messages explain)]
|
|
(t/is (well-formed? message))
|
|
(t/is (str/includes? message value))))
|
|
|
|
;; ---------------------------------------------------------------------
|
|
;; The value reported back to the plugin author is arbitrary JS data, so
|
|
;; rendering it must terminate and must not run plugin code.
|
|
|
|
(t/deftest test-error-messages-self-referencing-object
|
|
;; A plugin argument is a native JS value, and an object graph with a back
|
|
;; reference (`a.parent.child === a`) is ordinary. `pr-str` walks it forever,
|
|
;; so the error renderer would throw a RangeError from inside the error
|
|
;; handler itself: the author gets a stack overflow instead of a validation
|
|
;; error.
|
|
(let [a #js {}
|
|
b #js {}
|
|
_ (unchecked-set a "parent" b)
|
|
_ (unchecked-set b "child" a)
|
|
explain (sm/explain [:map [:value :string]] {:value a})
|
|
message (plugins.utils/error-messages explain)]
|
|
(t/is (str/includes? message "got object"))))
|
|
|
|
(t/deftest test-error-messages-object-with-getters
|
|
;; Penpot's own proxies expose their contents through getters that read the
|
|
;; application state and may throw for a stale id. Rendering a value must
|
|
;; never invoke them.
|
|
(let [called (atom 0)
|
|
value (js/Object.defineProperty
|
|
#js {:id "x"} "children"
|
|
#js {:enumerable true
|
|
:get (fn [] (swap! called inc) (throw (js/Error. "boom")))})
|
|
explain (sm/explain [:map [:value :string]] {:value value})
|
|
message (plugins.utils/error-messages explain)]
|
|
(t/is (str/includes? message "got object"))
|
|
(t/is (zero? @called))))
|
|
|
|
(t/deftest test-error-messages-deeply-nested-object
|
|
;; A deep graph must not produce an unbounded message.
|
|
(let [value (reduce (fn [acc _] #js {:child acc}) #js {:leaf 1} (range 200))
|
|
explain (sm/explain [:map [:value :string]] {:value value})
|
|
message (plugins.utils/error-messages explain)]
|
|
(t/is (str/includes? message "got object"))
|
|
(t/is (< (count message) 200))))
|
|
|
|
;; ---------------------------------------------------------------------
|
|
;; Issue #10072 — the reported example: `addToken` with a wrong token value.
|
|
;;
|
|
;; The token value schemas declare an `:error/fn` that only speaks about empty
|
|
;; values, so it returns nil for a wrong-typed one and `interpret-schema-problem`
|
|
;; degrades to the generic "Invalid data". A message that says nothing must not
|
|
;; win over one that says what was expected and what was received.
|
|
|
|
(t/deftest test-error-messages-token-value-numeric
|
|
(let [schema [:map [:value (cfo/make-token-value-schema :font-size)]]
|
|
message (plugins.utils/error-messages (sm/explain schema {:value 16}))]
|
|
(t/is (= "Field value is invalid: expected string, got number (16)" message))))
|
|
|
|
(t/deftest test-error-messages-token-value-opacity
|
|
(let [schema [:map [:value (cfo/make-token-value-schema :opacity)]]
|
|
message (plugins.utils/error-messages (sm/explain schema {:value true}))]
|
|
(t/is (= "Field value is invalid: expected string, got boolean (true)" message))))
|
|
|
|
(t/deftest test-error-messages-token-value-font-family
|
|
;; Both branches of the union are printable, so both are reported.
|
|
(let [schema [:map [:value (cfo/make-token-value-schema :font-family)]]
|
|
message (plugins.utils/error-messages (sm/explain schema {:value 16}))]
|
|
(t/is (= (str "Field value is invalid: "
|
|
"expected [:vector :app.common.schema/text] or TokenRef, got number (16)")
|
|
message))))
|
|
|
|
(t/deftest test-error-messages-token-value-empty-keeps-custom-message
|
|
;; When the schema's own `:error/fn` does render a message, it still wins.
|
|
(let [schema [:map [:value (cfo/make-token-value-schema :font-size)]]
|
|
message (plugins.utils/error-messages (sm/explain schema {:value ""}))]
|
|
(t/is (= "Field value is invalid: Empty input" message))))
|
|
|
|
(t/deftest test-reject-not-valid-rejects-an-error
|
|
;; Plugins read `.message` off the rejection, so it must be an Error.
|
|
(let [rejected (atom nil)]
|
|
(plugins.utils/reject-not-valid #(reset! rejected %) :someMethod "bad")
|
|
(t/is (instance? js/Error @rejected))
|
|
(t/is (str/includes? (.-message @rejected) "Code: :someMethod"))))
|