penpot/frontend/test/frontend_tests/logic/path_lifecycle_test.cljs
alonso.torres dabda4a752 🐛 Close the outline of a rect converted to a path
Converting a rect to a path gave an outline that went back to its start
with a line and stayed open, so a stroke missed its join at the first
corner. With the WASM engine on, the engine converts the rect and closes
the outline, so the two engines gave different paths for one shape.

The rect's outline now ends with `close-path`, as the WASM engine's does
(user decision). The path editor closes subpaths its own way on entry,
which its lifecycle test now expects.

Found by the WASM replay of the pinned generated programs (program 329),
which passes with the change.

Tests: `path-data-test/shape-to-path-rect-closes-its-outline`.

The conversion is outside the paths the component benchmark measures;
it is not run.

AI-assisted-by: claude-opus-5-5
2026-11-18 10:29:50 +01:00

613 lines
29 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.logic.path-lifecycle-test
(:require
[app.common.data.undo-stack :as u]
[app.common.geom.point :as gpt]
[app.common.test-helpers.files :as cthf]
[app.common.test-helpers.shapes :as cths]
[app.common.types.path :as path]
[app.main.data.workspace.drawing.common :as dwdc]
[app.main.data.workspace.edition :as dwe]
[app.main.data.workspace.path.changes :as path.changes]
[app.main.data.workspace.path.common :as path.common]
[app.main.data.workspace.path.drawing :as path.drawing]
[app.main.data.workspace.path.edition :as path.edition]
[app.main.data.workspace.path.helpers :as path.helpers]
[app.main.data.workspace.path.selection :as path.selection]
[app.main.data.workspace.path.shortcuts :as path.shortcuts]
[app.main.data.workspace.path.state :as path.state]
[app.main.data.workspace.path.streams :as path.streams]
[app.main.data.workspace.path.tools :as path.tools]
[app.main.data.workspace.path.undo :as path.undo]
[app.main.data.workspace.shortcuts :as wsc]
[beicon.v2.core :as rx]
[cljs.test :as t :include-macros true]
[frontend-tests.helpers.state :as ths]
[frontend-tests.logic.path-test-helpers :as pth]
[potok.v2.core :as ptk]))
(t/deftest path-lifecycle-selectors-use-the-active-path
(let [id (random-uuid)
edit-state {:edit-mode :draw}
edit-path {id edit-state}
state {:workspace-local {:edition id
:edit-path edit-path}
:workspace-drawing {:object {:id id :type :path}}}]
(t/is (= edit-state (path.state/current-edit-state state)))
(t/is (= edit-state (path.state/current-edit-state edit-path id)))
(t/is (path.state/editing? state))
(t/is (path.state/editing? edit-path id))
(t/is (path.state/drawing? edit-state id :path {:id id :type :path}))))
(t/deftest path-drawing-selector-finds-new-paths
(let [id (random-uuid)
state {:workspace-local {:edition nil
:edit-path {id {}}}
:workspace-drawing {:tool :path
:object {:id id :type :path}}}]
(t/is (path.state/drawing? state))
(t/is (not (path.state/editing? state)))
(t/is (path.state/drawing? nil nil :path {:id id :type :path}))
(t/is (not (path.state/drawing? nil nil :curve {:id id :type :path})))))
(t/deftest clear-edition-mode-finishes-path-streams
(t/is (path.streams/finish-edition? (dwe/clear-edition-mode)))
(t/is (not (path.streams/finish-edition? :interrupt))))
(t/deftest clear-edition-mode-finishes-active-path-before-finalizing
(let [id (random-uuid)
event (dwe/clear-edition-mode)
state {:workspace-local {:edition id
:edit-path {id {:edit-mode :move}}}
:workspace-drawing {:object {:id id}}}
state' (ptk/update event state)
emissions (atom [])]
(->> (ptk/watch event state' nil)
(rx/subs! #(swap! emissions conj %)))
(t/is (nil? (get-in state' [:workspace-local :edition])))
(t/is (some? (get-in state' [:workspace-local :edit-path id])))
(t/is (= [::path.common/finish-path]
(mapv ptk/type @emissions)))))
(t/deftest clear-non-path-edition-does-not-emit-finish-path
(let [id (random-uuid)
event (dwe/clear-edition-mode)
state {:workspace-local {:edition id}}
state' (ptk/update event state)
emissions (atom [])]
(->> (ptk/watch event state' nil)
(rx/subs! #(swap! emissions conj %)))
(t/is (nil? (get-in state' [:workspace-local :edition])))
(t/is (empty? @emissions))))
(t/deftest restarting-draw-mode-finishes-pending-subpath
(let [file (pth/setup-rect-file)
shape (-> (cths/get-shape file :rect1)
(path/convert-to-path))
id (:id shape)
last-point (last (path/get-points (:content shape)))
state {:workspace-local
{:edition id
:edit-path
{id {:edit-mode :draw
:last-point last-point
:preview {:command :line-to
:params {:x 150 :y 150}}
:old-content (:content shape)}}}
:workspace-drawing {:object shape}}
stream (rx/subject)
emissions (atom [])]
(->> (ptk/watch (path.drawing/start-draw-mode*) state stream)
(rx/take 4)
(rx/subs! #(swap! emissions conj %)))
(rx/push! stream (ptk/data-event ::path.drawing/end-edition
{:restart? true}))
(t/is (= [::path.drawing/start-edition
::path.common/finish-path
::path.drawing/check-changed-content
::path.drawing/start-draw-mode*]
(mapv ptk/type @emissions)))
(let [state' (ptk/update (second @emissions) state)
state'' (ptk/update (path.drawing/preview-next-point
{:x 200 :y 200})
state')]
(t/is (nil? (get-in state' [:workspace-local :edit-path id :last-point])))
(t/is (nil? (get-in state' [:workspace-local :edit-path id :preview])))
(t/is (= :move-to
(get-in state'' [:workspace-local :edit-path id :preview :command]))))))
(t/deftest escape-does-not-restart-edited-path-draw-loop
(let [id (random-uuid)
state {:workspace-local
{:edition id
:edit-path {id {:edit-mode :draw}}}}
stream (rx/subject)
emissions (atom [])]
(t/is (path.drawing/restart-draw-loop? (path.common/finish-path)))
(->> (ptk/watch (path.drawing/start-draw-mode*) state stream)
(rx/subs! #(swap! emissions conj %)))
(rx/push! stream (ptk/data-event ::path.drawing/end-edition
{:restart? false}))
(t/is (= [::path.drawing/start-edition]
(mapv ptk/type @emissions)))))
(defn- run-handle-drawing-end
"Runs the draw-ending flow and passes its events to `callback`."
([restart? callback]
(run-handle-drawing-end (pth/drawing-path-state) restart? callback))
([state restart? callback]
(let [stream (rx/subject)
emissions (atom [])]
(->> (ptk/watch (path.drawing/handle-drawing) state stream)
(rx/subs! #(swap! emissions conj %)))
(rx/push! stream (ptk/data-event ::path.drawing/end-edition
{:restart? restart?}))
;; Wait for the asynchronous drawing-end event.
(js/setTimeout
(fn []
(let [end-event (last @emissions)
end-emissions (atom [])]
(->> (ptk/watch end-event state stream)
(rx/subs! #(swap! end-emissions conj %)))
(callback @end-emissions)))))))
(t/deftest escape-ending-new-path-draw-does-not-reenter-edition
(t/async
done
(run-handle-drawing-end
false
(fn [emissions]
(t/is (= [::path.drawing/clean-drawn-content
::path.drawing/setup-frame
::dwdc/handle-finish-drawing
::dwe/clear-edition-mode]
(mapv ptk/type emissions)))
(done)))))
(t/deftest finishing-new-path-draw-reenters-edition
(t/async
done
(run-handle-drawing-end
true
(fn [emissions]
(t/is (= [::path.common/finish-path
::path.drawing/clean-drawn-content
::path.drawing/setup-frame
::dwdc/handle-finish-drawing
::path.drawing/start-created-path-edition]
(mapv ptk/type emissions)))
(done)))))
(t/deftest finishing-new-path-draw-in-move-mode-reenters-edition-in-move-mode
(t/async
done
(let [state (pth/drawing-path-state)
id (get-in state [:workspace-drawing :object :id])
state (assoc-in state [:workspace-local :edit-path id :edit-mode] :move)]
(run-handle-drawing-end
state
true
(fn [emissions]
(let [edition-emissions (atom [])]
(->> (ptk/watch (last emissions) state nil)
(rx/subs! #(swap! edition-emissions conj %)))
(let [change-mode (last @edition-emissions)
edited {:workspace-local {:edition id
:edit-path {id {:edit-mode :draw}}}}]
(t/is (= ::path.drawing/change-edit-mode (ptk/type change-mode)))
(t/is (= :move (get-in (ptk/update change-mode edited)
[:workspace-local :edit-path id :edit-mode])))))
(done))))))
(t/deftest move-mode-while-creating-path-finishes-it
(let [id (random-uuid)
state {:workspace-local
{:edit-path {id {:edit-mode :draw
:last-point (gpt/point 10 10)}}}
:workspace-drawing {:tool :path
:object {:id id :type :path}}}
event (path.drawing/change-edit-mode :move)
state' (ptk/update event state)
emissions (atom [])]
(t/is (= :move (get-in state' [:workspace-local :edit-path id :edit-mode])))
(->> (ptk/watch event state' nil)
(rx/subs! #(swap! emissions conj %)))
(t/is (= [::path.common/finish-path]
(mapv ptk/type @emissions)))))
(t/deftest ending-a-draw-collapses-the-nodes-drawn-on-top-of-each-other
(t/async
done
(run-handle-drawing-end
false
(fn [emissions]
;; A path drawn back onto one of its own nodes and then closed.
(let [clean (first (filter #(= ::path.drawing/clean-drawn-content (ptk/type %))
emissions))
state {:workspace-drawing
{:object {:id (random-uuid)
:type :path
:content (path/content
[{:command :move-to :params {:x 0 :y 0}}
{:command :line-to :params {:x 10 :y 5}}
{:command :line-to :params {:x 20 :y 10}}
{:command :line-to :params {:x 10 :y 5}}
{:command :close-path :params {}}])}}}
content (-> (ptk/update clean state)
(get-in [:workspace-drawing :object :content]))]
(t/is (= [:move-to :line-to :line-to] (mapv :command (vec content))))
(t/is (= 1 (count (path/point-indices content (gpt/point 10.0 5.0)))))
(done))))))
(t/deftest escape-with-pending-segment-cancels-it-and-keeps-drawing
(let [id (random-uuid)
state {:workspace-local
{:edition id
:edit-path {id {:edit-mode :draw
:last-point (gpt/point 10 10)
:preview {:command :line-to
:params {:x 20 :y 20}}}}}}
emissions (atom [])]
(->> (ptk/watch (path.shortcuts/esc-pressed) state nil)
(rx/subs! #(swap! emissions conj %)))
(t/is (= [::path.common/cancel-pending-segment]
(mapv ptk/type @emissions)))
(let [state' (ptk/update (first @emissions) state)]
(t/is (nil? (get-in state' [:workspace-local :edit-path id :last-point])))
(t/is (nil? (get-in state' [:workspace-local :edit-path id :preview])))
(t/is (= :draw (get-in state' [:workspace-local :edit-path id :edit-mode]))))))
(t/deftest escape-while-creating-path-finishes-it-into-edition
(let [id (random-uuid)
state {:workspace-local
{:edit-path {id {:edit-mode :draw
:last-point (gpt/point 10 10)}}}
:workspace-drawing {:object {:id id :type :path}}}
emissions (atom [])]
(->> (ptk/watch (path.shortcuts/esc-pressed) state nil)
(rx/subs! #(swap! emissions conj %)))
;; Finishing creates the shape and clears its pending segment.
(t/is (= [::path.common/finish-path]
(mapv ptk/type @emissions)))))
(t/deftest deselect-all-shortcut-replaces-the-grid-layout-toggle
(let [deselect-all (:deselect-all path.shortcuts/shortcuts)
grid-toggle (:toggle-layout-grid wsc/shortcuts)]
(t/is (= (:command grid-toggle) (:command deselect-all)))
(t/is (true? (:overwrite deselect-all)))))
(t/deftest escape-without-pending-segment-interrupts-edition
(let [id (random-uuid)
state {:workspace-local
{:edition id
:edit-path {id {:edit-mode :draw}}}}
emissions (atom [])]
(->> (ptk/watch (path.shortcuts/esc-pressed) state nil)
(rx/subs! #(swap! emissions conj %)))
(t/is (= [:interrupt] @emissions))))
(t/deftest editing-path-only-updates-drawing-copy
(t/async
done
(let [file (pth/setup-rect-file)
original-rect (cths/get-shape file :rect1)
id (:id original-rect)
delta (gpt/point 10 5)
store (ths/setup-store file)
events (conj (pth/start-path-edition-events id)
(pth/move-drawing-content delta))]
(ths/run-store
store done events
(fn [new-state]
(let [file' (ths/get-file-from-state new-state)
stored-shape (cths/get-shape file' :rect1)
drawing-copy (get-in new-state [:workspace-drawing :object])]
(t/is (= original-rect stored-shape))
(t/is (= :path (:type drawing-copy)))
;; the editor edits the converted outline with its subpaths closed
(t/is (= (path/move-content
(path/close-subpaths (:content (path/convert-to-path original-rect)))
delta)
(:content drawing-copy)))))))))
(t/deftest unchanged-path-edition-preserves-simple-shape
(t/async
done
(let [file (pth/setup-rect-file)
original-rect (cths/get-shape file :rect1)
id (:id original-rect)
store (ths/setup-store file)
events (conj (pth/start-path-edition-events id) :interrupt)]
(ths/run-store
store done events
(fn [new-state]
(let [file' (ths/get-file-from-state new-state)
stored-shape (cths/get-shape file' :rect1)]
(t/is (= original-rect stored-shape))
(t/is (= :rect (:type stored-shape)))
(t/is (nil? (get-in new-state [:workspace-drawing :object])))))))))
(t/deftest changed-path-edition-is-persisted-when-finalized
(t/async
done
(let [file (pth/setup-rect-file)
original-rect (cths/get-shape file :rect1)
id (:id original-rect)
delta (gpt/point 10 5)
original-path (path/convert-to-path original-rect)
;; Persist the rectangle with an explicit close command.
changed-content (-> (:content original-path)
(path/move-content delta)
(path/close-loops))
expected-shape (-> original-path
(assoc :content changed-content)
(path/update-geometry))
store (ths/setup-store file)
events (into (pth/start-path-edition-events id)
[(pth/move-drawing-content delta)
:interrupt])]
(ths/run-store
store done events
(fn [new-state]
(let [file' (ths/get-file-from-state new-state)
stored-shape (cths/get-shape file' :rect1)]
(t/is (= expected-shape stored-shape))
(t/is (= :path (:type stored-shape)))
(t/is (nil? (get-in new-state [:workspace-drawing :object])))))))))
(t/deftest created-path-edition-cleans-drawing-state-on-exit
(t/async
done
(let [file (pth/setup-rect-file)
original-rect (cths/get-shape file :rect1)
id (:id original-rect)
store (ths/setup-store file)
events [(path.drawing/start-created-path-edition id)
:interrupt]]
(ths/run-store
store done events
(fn [new-state]
(let [file' (ths/get-file-from-state new-state)
stored-shape (cths/get-shape file' :rect1)]
(t/is (= original-rect stored-shape))
(t/is (nil? (get-in new-state [:workspace-local :edition])))
(t/is (nil? (get-in new-state [:workspace-local :edit-path id])))
(t/is (nil? (get-in new-state [:workspace-drawing :object])))))))))
(defn- with-dangling-subpath-start
[content]
(path/content (conj (vec content)
{:command :move-to
:params {:x 30 :y 40}})))
(t/deftest cancel-pending-segment-drops-dangling-subpath-start
(let [id (random-uuid)
content (pth/selectable-path-content)
state {:workspace-local
{:edition id
:edit-path {id {:edit-mode :draw
:last-point (gpt/point 30 40)
:preview {:command :line-to
:params {:x 50 :y 50}}}}}
:workspace-drawing
{:object {:id id
:type :path
:content (with-dangling-subpath-start content)}}}
state' (ptk/update (path.common/cancel-pending-segment) state)]
(t/is (= (vec content)
(vec (get-in state' [:workspace-drawing :object :content]))))
(t/is (nil? (get-in state' [:workspace-local :edit-path id :last-point])))
(t/is (nil? (get-in state' [:workspace-local :edit-path id :preview])))))
(t/deftest finish-path-drops-dangling-subpath-start
(let [id (random-uuid)
content (pth/selectable-path-content)
state {:workspace-local
{:edition id
:edit-path {id {:edit-mode :draw
:last-point (gpt/point 30 40)}}}
:workspace-drawing
{:object {:id id
:type :path
:content (with-dangling-subpath-start content)}}}
state' (ptk/update (path.common/finish-path) state)]
(t/is (= (vec (path/close-subpaths content))
(vec (get-in state' [:workspace-drawing :object :content]))))
(t/is (nil? (get-in state' [:workspace-local :edit-path id :last-point])))))
(t/deftest finalize-ignores-dangling-subpath-start
(let [file (pth/setup-rect-file)
rect (cths/get-shape file :rect1)
id (:id rect)
path-shape (path/convert-to-path rect)
old-content (:content path-shape)
state {:current-file-id (:id file)
:current-page-id (cthf/current-page-id file)
:files {(:id file) file}
:workspace-local
{:edition id
:edit-path {id {:old-content old-content}}}
:workspace-drawing
{:object (assoc path-shape
:content
(with-dangling-subpath-start old-content))}}
emissions (atom [])]
(->> (ptk/watch (path.changes/finalize-path-content id) state nil)
(rx/subs! #(swap! emissions conj %)))
(t/is (empty? @emissions))))
(t/deftest next-point-preview-is-suppressed-during-a-modifier-drag
(let [id (random-uuid)
content (path/content [{:command :move-to :params {:x 0 :y 0}}
{:command :line-to :params {:x 100 :y 0}}])
mk (fn [modifiers]
;; Draw mode keeps the path in the drawing object.
{:workspace-drawing {:object {:id id :type :path :content content}}
:workspace-local {:edition nil
:zoom 1
:edit-path {id {:edit-mode :draw
:last-point (gpt/point 100 0)
:content-modifiers modifiers}}}})
event (path.drawing/preview-next-point {:x 150 :y 40 :shift? false})
idle (ptk/update event (mk {}))
during (ptk/update event (mk {1 {:c1x 5 :c1y 5}}))]
;; no active drag: the next-point preview updates as usual
(t/is (some? (get-in idle [:workspace-local :edit-path id :preview])))
;; a placed handler is being dragged mid-draw: the preview must not move
(t/is (nil? (get-in during [:workspace-local :edit-path id :preview])))))
(t/deftest dragging-the-current-curve-forward-handle-while-drawing
(let [id (random-uuid)
content (path/content [{:command :move-to :params {:x 0 :y 0}}
{:command :curve-to
:params {:x 100 :y 0 :c1x 30 :c1y 0 :c2x 70 :c2y 0}}])
mk (fn []
;; Store the backward handle and transient forward handle.
{:workspace-drawing {:object {:id id :type :path :content content}}
:workspace-local {:edition nil
:zoom 1
:edit-path {id {:edit-mode :draw
:last-point (gpt/point 100 0)
:prev-handler (gpt/point 130 0)}}}})
drag (fn [alt?]
(ptk/update (path.drawing/drag-prev-handler
{:x 100 :y 50 :alt? alt? :shift? false})
(mk)))
finish (fn [state] (ptk/update (path.drawing/finish-drag) state))
c2-of (fn [state]
(-> (get-in state [:workspace-drawing :object :content])
(vec) (nth 1) :params (select-keys [:c2x :c2y])))]
(t/testing "no alt: the forward handle follows the pointer and the committed backward handle mirrors it"
(let [dragged (drag false)]
;; the forward handle tracks the pointer
(t/is (= (gpt/point 100 50)
(get-in dragged [:workspace-local :edit-path id :drag-handler])))
;; the stale transient forward handle is cleared so it is not double-rendered
(t/is (nil? (get-in dragged [:workspace-local :edit-path id :prev-handler])))
(let [committed (finish dragged)]
;; c2 = 2*node - forward = (100,-50)
(t/is (= {:c2x 100 :c2y -50} (c2-of committed)))
;; the new forward handle becomes the prev-handler
(t/is (= (gpt/point 100 50)
(get-in committed [:workspace-local :edit-path id :prev-handler]))))))
(t/testing "alt: the forward handle moves on its own, the backward handle stays put"
(let [committed (finish (drag true))]
(t/is (= {:c2x 70 :c2y 0} (c2-of committed)))))))
(t/deftest dragging-the-current-curve-backward-handle-while-drawing
;; Dragging the backward handle mirrors the transient forward handle.
(let [id (random-uuid)
content (path/content [{:command :move-to :params {:x 0 :y 0}}
{:command :curve-to
:params {:x 100 :y 0 :c1x 30 :c1y 0 :c2x 70 :c2y 0}}])
mk (fn []
{:workspace-drawing {:object {:id id :type :path :content content}}
:workspace-local {:edition nil
:zoom 1
:edit-path {id {:edit-mode :draw
:last-point (gpt/point 100 0)
:prev-handler (gpt/point 130 0)}}}})
;; Drag the backward handle to `(70, -40)`.
drag (fn [mode]
(ptk/update (path.edition/modify-selected-handlers
id [1 :c2] {} 0 -40 mode (= mode :smart))
(mk)))
prev-of (fn [state] (get-in state [:workspace-local :edit-path id :prev-handler]))]
(t/testing "smart (no modifier): the forward handle mirrors the angle, keeping its own length"
;; Keep the forward handle's length while mirroring its angle.
(t/is (= (gpt/point 118 24) (prev-of (drag :smart)))))
(t/testing "mirror (mod): the forward handle full-mirrors to equal length"
;; Mirror the forward handle around the node.
(t/is (= (gpt/point 130 40) (prev-of (drag :mirror)))))
(t/testing "independent (alt): the forward handle is left untouched"
(t/is (= (gpt/point 130 0) (prev-of (drag :independent)))))))
(t/deftest path-local-undo-redo-restores-content-and-clears-preview
(let [id (random-uuid)
content-a (path/content [{:command :move-to :params {:x 0 :y 0}}
{:command :line-to :params {:x 10 :y 0}}])
content-b (path/content [{:command :move-to :params {:x 0 :y 0}}
{:command :line-to :params {:x 10 :y 5}}])
base (-> (pth/selectable-path-state id content-a path.helpers/empty-selection)
(assoc-in [:workspace-local :edit-path id :undo-stack] (u/make-stack)))
;; Capture both content states around a stale preview.
s1 (ptk/update (path.undo/add-undo-entry) base)
s2 (-> (path.state/set-content s1 content-b)
(assoc-in [:workspace-local :edit-path id :preview]
{:command :line-to :params {:x 99 :y 99}}))
s3 (ptk/update (path.undo/add-undo-entry) s2)
s4 (ptk/update (path.undo/undo-path) s3)
s5 (ptk/update (path.undo/redo-path) s4)]
(t/is (= content-b (path.state/get-path s3 :content)))
(t/is (= content-a (path.state/get-path s4 :content)))
;; Restoring an entry drops its render-only preview.
(t/is (nil? (get-in s4 [:workspace-local :edit-path id :preview])))
(t/is (= content-b (path.state/get-path s5 :content)))))
(t/deftest path-undo-entry-never-captures-the-transient-preview
(let [id (random-uuid)
state (-> (pth/selectable-path-state id (pth/selectable-path-content)
path.helpers/empty-selection)
(assoc-in [:workspace-local :edit-path id :undo-stack] (u/make-stack))
(assoc-in [:workspace-local :edit-path id :preview]
{:command :line-to :params {:x 99 :y 99}}))
state' (ptk/update (path.undo/add-undo-entry) state)
entry (u/peek (get-in state' [:workspace-local :edit-path id :undo-stack]))]
(t/is (some? entry))
(t/is (not (contains? entry :preview)))))
;; Tool operations through the full edition lifecycle.
(t/deftest tool-make-curve-persists-through-edition-lifecycle
(t/async
done
(let [file (pth/setup-rect-file)
rect (cths/get-shape file :rect1)
id (:id rect)
store (ths/setup-store file)
events (into (pth/start-path-edition-events id)
[(path.selection/select-node 1 false)
(path.tools/make-curve)
:interrupt])]
(ths/run-store
store done events
(fn [new-state]
(let [stored (cths/get-shape (ths/get-file-from-state new-state) :rect1)]
(t/is (= :path (:type stored)))
;; make-curve on a corner introduces at least one curve segment
(t/is (some #(= :curve-to (:command %)) (seq (:content stored))))
(t/is (nil? (get-in new-state [:workspace-drawing :object])))))))))
(t/deftest tool-remove-node-persists-through-edition-lifecycle
(t/async
done
(let [file (pth/setup-rect-file)
rect (cths/get-shape file :rect1)
id (:id rect)
orig-nodes (count (path/get-points (:content (path/convert-to-path rect))))
store (ths/setup-store file)
events (into (pth/start-path-edition-events id)
[(path.selection/select-node 1 false)
(path.tools/remove-node)
:interrupt])]
(ths/run-store
store done events
(fn [new-state]
(let [stored (cths/get-shape (ths/get-file-from-state new-state) :rect1)]
(t/is (= :path (:type stored)))
;; removing a node leaves fewer nodes than the converted rect had
(t/is (< (count (path/get-points (:content stored))) orig-nodes))
(t/is (nil? (get-in new-state [:workspace-drawing :object])))))))))