mirror of
https://github.com/penpot/penpot.git
synced 2026-11-21 01:22:01 +00:00
Two turned-shape programs of the frontend replay differed from the composable model: - Setting a turned variant to fill in its hugging variant board: the sidebar fixes the board's width first, the model's property edit did not, and a layout pass of a fill child in a hugging row collapses a turned child before growing it, which left it a singular transform. The model's edit of a layout child now applies the same sizing fixes (`cls/fix-child-sizing`, `cls/fix-parent-sizing`). - A swapped head turned with its main, filling a row: the frontend's layout update settles the placement of the copy shapes it moves, which gives the head its main's unskewed turn; the model's reflow did not, and kept the layout's skew. The model's reflow settles them too (`cll/generate-sync-transformed-placement`). Both programs now pass in the frontend replay with WASM off (frontend generated tests). Harness only; the benchmark is not run. Also in this commit: - Log each shape's parent id in the WASM replay's debug output. The debug log named each shape's parent, which copies and their mains share; it now gives the parent's id too, so a subtree can be told apart from its copies'. AI-assisted-by: claude-opus-5-5
1194 lines
72 KiB
Clojure
1194 lines
72 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.composable-tests.generated-test
|
|
(:require
|
|
[app.common.test-helpers.composable.comp.files :as cf]
|
|
[app.common.test-helpers.composable.comp.nodes :as n]
|
|
[app.common.test-helpers.composable.comp.undo-check :as uc]
|
|
[app.common.test-helpers.composable.core :as tm]
|
|
[app.common.test-helpers.composable.gen :as cg]
|
|
[app.common.test-helpers.composable.grid :as grid]
|
|
[app.common.test-helpers.composable.oracle :as oracle]
|
|
[app.common.test-helpers.files :as cthf]
|
|
[app.common.test-helpers.normalize :as thn]
|
|
[app.common.test-helpers.shapes :as cths]
|
|
[app.main.data.workspace.libraries :as dwl]
|
|
[app.main.data.workspace.undo :as dwu]
|
|
[app.main.repo :as rp]
|
|
[app.main.store :as st]
|
|
[beicon.v2.core :as rx]
|
|
[cljs.reader :as reader]
|
|
[cljs.test :as t :include-macros true]
|
|
[clojure.test.check.generators :as gen]
|
|
[frontend-tests.composable-tests.interpreter :as ftm]
|
|
[frontend-tests.helpers.mock :as mock]))
|
|
|
|
(t/use-fixtures :each ftm/fixture)
|
|
|
|
(defn- live-model
|
|
[state live]
|
|
(let [by-path (into {} (map (juxt :path (comp :id :shape))) (cg/forest live))
|
|
ids-map (into {} (keep (fn [{:keys [path shape]}]
|
|
(when-let [id (get by-path path)] [(:id shape) id])))
|
|
(cg/forest (:situation state)))]
|
|
(into {}
|
|
(keep (fn [{:keys [path shape]}]
|
|
(when-let [groups (get (:model state) (:id shape))]
|
|
(when-let [id (get by-path path)] [id (grid/remap-groups groups ids-map)]))))
|
|
(cg/forest (:situation state)))))
|
|
|
|
(defn ^:async replay-program
|
|
"Replay a JVM-shrunk EDN program against the async frontend. The pure
|
|
runner chooses targets independently and both must make the same choices."
|
|
[{:keys [world ops] :as program}]
|
|
(try
|
|
(let [initial (cg/initial-state world)]
|
|
(loop [state initial
|
|
live (ftm/start-generated (:situation initial))
|
|
tuples ops]
|
|
(if-let [tuple (first tuples)]
|
|
(let [state (cg/settle-state state)
|
|
pure (:situation state)
|
|
live (ftm/refresh-generated live)
|
|
expected (cg/resolve-op pure (:model state) tuple)
|
|
actual (if (#{:undo :redo :library-undo :library-redo} (first tuple))
|
|
expected
|
|
(cg/resolve-op live (live-model state live) tuple))]
|
|
(t/is (= (:trace expected) (:trace actual)) (str "Replay changed a target: " tuple))
|
|
(let [next-live (try (if-let [op (:op actual)]
|
|
(if-let [owner (:library-id actual)]
|
|
(await (ftm/run-generated-source-step live owner op))
|
|
(await (ftm/run-generated-step live op)))
|
|
(do
|
|
(t/is (= :settled (await (ftm/await-step []))))
|
|
(ftm/refresh-generated live)))
|
|
(catch :default error
|
|
(throw (ex-info (ex-message error)
|
|
(assoc (ex-data error) :replay-tuple tuple) error))))
|
|
next-state (-> state (cg/step tuple) (cg/settle-state))]
|
|
(when-not next-live
|
|
(throw (ex-info "Frontend step failed" {:program program :tuple tuple})))
|
|
(when (and (:op actual) (= :update-main (first tuple)))
|
|
(oracle/check-requested-update-main live next-live (live-model state live)
|
|
(get-in actual [:shape :id])))
|
|
(when (and (:op actual) (#{:resize :rotate :transform} (first tuple)))
|
|
(oracle/check-requested-geometry
|
|
(:objects (cthf/current-page (tm/file next-live)))
|
|
(tm/shape-by-id next-live (get-in actual [:shape :id]))
|
|
(cg/requested-geometry live actual (first tuple))))
|
|
(when (and (:op actual) (#{:grid-cell :grid-direction} (first tuple)))
|
|
(oracle/check-requested-grid
|
|
(tm/shape-by-id next-live (get-in actual [:shape :id])) (:shape actual)
|
|
(get-in actual [:op :action]) (get-in actual [:op :value])))
|
|
(try
|
|
(oracle/check next-live (live-model next-state next-live))
|
|
(catch :default error
|
|
(throw (ex-info (str "Frontend oracle at " tuple ": " (ex-message error))
|
|
(assoc (ex-data error) :replay-tuple tuple) error))))
|
|
(let [parity {:relative-free-head-placement true}
|
|
expected (oracle/canonical (:situation next-state) parity)
|
|
actual (oracle/canonical next-live parity)]
|
|
(t/is (true? (oracle/equivalent? expected actual))
|
|
(str "Backend mismatch at " tuple "; replay " (pr-str program)
|
|
"; first " (pr-str (oracle/inequivalence expected actual))
|
|
"; diff " (pr-str (thn/diff expected actual)))))
|
|
(t/is (empty? (uc/failures next-live)) (pr-str (uc/failures next-live)))
|
|
(recur next-state next-live (rest tuples))))
|
|
(let [checked (await (ftm/finish-generated live))]
|
|
(t/is (empty? (uc/failures checked)) (pr-str (uc/failures checked)))
|
|
(ftm/uninstall!)))))
|
|
(catch :default error
|
|
(ftm/uninstall!)
|
|
(throw error))))
|
|
|
|
(defn ^:async replay
|
|
[program]
|
|
(await (mock/with-mocks* {rp/cmd! mock/rpc-cmd-mock
|
|
rx/timer mock/timer-mock}
|
|
(try (await (replay-program program))
|
|
(catch :default error
|
|
(t/is false (str (ex-message error) "\nReplay: " (pr-str program)
|
|
"\nDetails: " (pr-str (ex-data error)))))))))
|
|
|
|
(defn- ^:async replay-library-grid-with-source-control
|
|
[program]
|
|
(await
|
|
(mock/with-mocks* {rp/cmd! mock/rpc-cmd-mock rx/timer mock/timer-mock}
|
|
(t/is (map? (cg/run program)))
|
|
;; The same source edits are valid when the source owns the editor.
|
|
(let [situation (cg/world (:world program))
|
|
files (cf/all-files situation)
|
|
owner (first (keys (tm/aux-files situation)))
|
|
parent-id (get-in (cg/resolve-op situation {} [:library-add-child 0]) [:shape :id])
|
|
editor (-> situation (tm/with-file (get files owner)) (tm/with-aux-files (dissoc files owner)))
|
|
initial (ftm/start-generated editor)
|
|
before (ftm/snapshot)
|
|
first (await (ftm/run-generated-step initial (n/add-child (constantly parent-id) :source-a :width 20 :height 20)))
|
|
second (await (ftm/run-generated-step first (n/add-child (constantly parent-id) :source-b :width 20 :height 20)))
|
|
shape (tm/shape-by-id second parent-id)]
|
|
(t/is (= 5 (count (:shapes shape))))
|
|
(t/is (= [2 3] (mapv #(count (get shape %)) [:layout-grid-rows :layout-grid-columns])))
|
|
(t/is (= (dissoc (:files before) owner) (dissoc (:files (ftm/snapshot)) owner)))
|
|
(t/is (empty? (uc/failures (await (ftm/finish-generated second)))))
|
|
(ftm/uninstall!))
|
|
(await (replay-program program)))))
|
|
|
|
(def update-main-intent-programs
|
|
[{:world [1 0] :ops [[:edit 0 0 1 1] [:update-main 0] [:undo] [:redo]]}
|
|
{:world [1 0 {:library true}] :ops [[:edit 0 0 1 2] [:update-main 0] [:undo] [:redo]]}
|
|
{:world [1 0 {:library true :stale-libraries true}]
|
|
:ops [[:edit 0 0 1 2] [:update-main 0] [:undo] [:redo]]}
|
|
{:world [1 0 {:layout :grid :layout-children true :grid-square true}]
|
|
:ops [[:grid-cell 0 0 0 1] [:update-main 0] [:undo] [:redo]]}
|
|
{:world [1 0 {:library true :library-depth 0 :library-grid true}]
|
|
:ops [[:grid-cell 0 0 0 2] [:update-main 0] [:undo] [:redo]]}
|
|
{:world [1 0 {:library true :library-depth 0 :library-grid true :stale-libraries true}]
|
|
:ops [[:grid-cell 0 0 0 2] [:update-main 0] [:undo] [:redo]]}
|
|
{:world [1 0 {:text true :text-styles true}]
|
|
:ops [[:text-style 1 2 1] [:update-main 0] [:undo] [:redo]]}
|
|
{:world [1 0] :ops [[:transform 0 3 2 4] [:update-main 0] [:undo] [:redo]]}])
|
|
|
|
(t/deftest ^:async update-main-preserves-authored-intent-in-the-destination
|
|
(doseq [program update-main-intent-programs]
|
|
(await (replay program))))
|
|
|
|
(t/deftest ^:async update-main-intent-rejects-a-reset-dispatched-by-the-editor
|
|
(await
|
|
(mock/with-mocks* {rp/cmd! mock/rpc-cmd-mock rx/timer mock/timer-mock}
|
|
(doseq [{:keys [world ops]} update-main-intent-programs]
|
|
(let [state (cg/initial-state world)
|
|
live (ftm/start-generated (:situation state))
|
|
edit (first ops)
|
|
edited (await (ftm/run-generated-step live (:op (cg/resolve-op live {} edit))))
|
|
state (-> state (cg/step edit) cg/settle-state)
|
|
model (live-model state edited)
|
|
request (cg/resolve-op edited model [:update-main 0])
|
|
result (await (mock/with-mocks* {dwl/update-component-sync (fn ([id _] (dwl/reset-component id)) ([id _ _] (dwl/reset-component id)))}
|
|
(await (ftm/run-generated-step edited (:op request)))))
|
|
settled (try (oracle/check result {}) nil
|
|
(catch :default error (ex-data error)))
|
|
failure (try (oracle/check-requested-update-main edited result model (get-in request [:shape :id])) nil
|
|
(catch :default error (ex-data error)))]
|
|
(t/is (nil? settled) "The wrong main and every copy agree")
|
|
(t/is (= :I9 (:invariant failure)) (pr-str failure))
|
|
(t/is (= :requested-update-main (:phase failure)) (pr-str failure))
|
|
(let [checked (await (ftm/finish-generated result))]
|
|
(t/is (empty? (uc/failures checked)) (pr-str (uc/failures checked))))
|
|
(ftm/uninstall!)
|
|
(let [failure (await (mock/with-mocks* {dwl/update-component-sync (fn ([id _] (dwl/reset-component id)) ([id _ _] (dwl/reset-component id)))}
|
|
(try (await (replay-program {:world world :ops ops})) nil
|
|
(catch :default error (ex-data error)))))]
|
|
(t/is (= :I9 (:invariant failure)) (pr-str failure))
|
|
(t/is (= :requested-update-main (:phase failure)) (pr-str failure))))))))
|
|
|
|
(t/deftest ^:async empty-grid-direction-edits-replay-through-the-frontend
|
|
(doseq [depth [0 1]
|
|
scope [nil 1]]
|
|
(await (replay {:world [1 depth {:layout :grid :grid-empty true}]
|
|
:ops [[:grid-cell 0 0 0 scope] [:grid-direction 0 0 1 scope]
|
|
[:undo] [:redo]]}))))
|
|
|
|
(t/deftest ^:async empty-grid-direction-histories-replay-through-the-frontend
|
|
(doseq [depth [0 1]
|
|
tail [[[:grid-direction 0 0 0 1]] [[:update-main 0]] [[:reset 0]]
|
|
[[:duplicate 0]] [[:detach 0]] [[:add-child 0]]]]
|
|
(await (replay {:world [1 depth {:layout :grid :grid-empty true}]
|
|
:ops (into [[:grid-direction 0 0 1 1]] (concat tail [[:sync] [:undo] [:redo]]))}))))
|
|
|
|
(t/deftest ^:async grid-growth-replays-with-independent-cell-expectations
|
|
(doseq [direction [:row :column]
|
|
turn-copy? [false true]]
|
|
(await (replay {:world [1 0 {:layout :grid :layout-children true :grid-square true}]
|
|
:ops (vec (concat (when (= direction :column) [[:grid-direction 0 0 1 0]])
|
|
[[:grid-cell 0 0 0 1]]
|
|
(when turn-copy? [[:grid-direction 0 0 (if (= direction :row) 1 0) 1]])
|
|
[[:add-child 0] [:add-child 0] [:sync] [:undo] [:redo]]))}))))
|
|
|
|
(t/deftest ^:async grid-growth-context-replays-through-structural-and-library-operations
|
|
(doseq [program
|
|
(concat
|
|
(for [tail [[[:duplicate 0] [:undo] [:redo]] [[:update-main 0] [:undo] [:redo]]
|
|
[[:reset 0] [:undo] [:redo]] [[:detach 0] [:undo] [:redo]]]]
|
|
{:world [1 0 {:layout :grid :layout-children true :grid-square true}]
|
|
:ops (into [[:grid-cell 0 0 0 1] [:add-child 0] [:add-child 0] [:sync 1]] tail)})
|
|
[{:world [1 1 {:layout :grid :layout-children true :grid-square true}]
|
|
:ops [[:grid-cell 0 0 0 1] [:add-child 0] [:add-child 0] [:sync 1] [:detach 0] [:undo] [:redo]]}
|
|
{:world [1 0 {:library true :library-depth 0 :library-grid true :stale-libraries true}]
|
|
:ops [[:grid-cell 0 0 0 2] [:library-add-child 0] [:library-add-child 0]
|
|
[:edit 0 1 1 2] [:library-sync] [:undo] [:redo]]}])]
|
|
(if (get-in program [:world 2 :stale-libraries])
|
|
(await (replay-library-grid-with-source-control program))
|
|
(await (replay program)))))
|
|
|
|
(t/deftest ^:async source-grid-additions-replay-without-accepting-the-library
|
|
(await (replay {:world [1 0 {:library true :library-depth 0 :library-grid true :stale-libraries true}]
|
|
:ops [[:grid-cell 0 0 0 2] [:library-add-child 0] [:library-add-child 0]
|
|
[:edit 0 1 1 2] [:undo] [:redo]]})))
|
|
|
|
(t/deftest ^:async accepting-source-grid-growth-keeps-oracle-references-through-undo
|
|
(await (replay {:world [1 0 {:library true :library-depth 0 :library-grid true :stale-libraries true}]
|
|
:ops [[:grid-cell 0 0 0 2] [:library-add-child 0] [:library-add-child 0]
|
|
[:edit 0 1 1 2] [:library-sync] [:undo] [:redo]]})))
|
|
|
|
(t/deftest ^:async accepted-reference-history-keeps-newer-loaded-sources-independent
|
|
(doseq [ops [[[:library-add-child 0] [:library-sync] [:library-add-child 0]
|
|
[:library-sync] [:undo] [:undo] [:redo] [:redo]]
|
|
[[:library-add-child 0] [:library-sync] [:edit 0 1 1 2]
|
|
[:undo] [:undo] [:redo] [:redo]]
|
|
[[:library-edit 0 0 1] [:library-sync] [:library-edit 0 0 2]
|
|
[:undo] [:redo]]]]
|
|
(await (replay {:world [0 0 {:library true :library-depth 0 :library-grid true :stale-libraries true}]
|
|
:ops ops}))))
|
|
|
|
(t/deftest ^:async selective-library-pulls-retain-independent-reference-histories
|
|
(doseq [kind [:reset :swap :switch]]
|
|
(t/testing (name kind)
|
|
(await
|
|
(mock/with-mocks* {rp/cmd! mock/rpc-cmd-mock rx/timer mock/timer-mock}
|
|
(let [initial (cg/world [0 0 {:library true :library-depth 0 :library-variants true :stale-libraries true}])
|
|
resolved (cg/resolve-op initial {} [kind 0])
|
|
target (get-in resolved [:shape :id])
|
|
main (if (= kind :reset)
|
|
(get-in resolved [:shape :shape-ref])
|
|
(get-in resolved [:destination :id]))
|
|
owner (get-in resolved [:shape :component-file])
|
|
source (get (cf/all-files initial) owner)
|
|
child (first (:shapes (tm/shape-by-id (tm/with-file initial source) main)))
|
|
control (first (for [{:keys [shape]} (cg/tree initial)
|
|
:when (and (= main (:shape-ref shape)) (not= target (:id shape)))]
|
|
(:id shape)))
|
|
old-fill (get-in (tm/shape-by-id (tm/with-file initial source) child) [:fills 0 :fill-color])
|
|
live (ftm/start-generated initial)
|
|
live (await (ftm/run-generated-source-step live owner
|
|
(n/change-property (constantly child) :fills "#00ff00")))
|
|
loaded (get (cf/all-files live) owner)
|
|
before (tm/file live)
|
|
prior (get (cf/reference-libraries live (tm/shape-by-id live target)) owner)
|
|
live (await (ftm/run-generated-step live (:op resolved)))
|
|
after (tm/file live)
|
|
head (tm/shape-by-id live target)
|
|
pulled (tm/shape-by-id live (first (:shapes head)))
|
|
stale (tm/shape-by-id live (first (:shapes (tm/shape-by-id live control))))]
|
|
(t/is (some? control))
|
|
(t/is (= "#00ff00" (get-in pulled [:fills 0 :fill-color])))
|
|
(t/is (= old-fill (get-in stale [:fills 0 :fill-color])))
|
|
(t/is (= (:data loaded) (:data (get (cf/reference-libraries live head) owner))))
|
|
(t/is (= (:data source) (:data (get (cf/reference-libraries live (tm/shape-by-id live control)) owner))))
|
|
(t/is (nil? (oracle/check live {})))
|
|
(let [live (await (ftm/run-generated-step live (n/undo)))]
|
|
(t/is (= before (tm/file live)))
|
|
(t/is (= (:data prior) (:data (get (cf/reference-libraries live (tm/shape-by-id live target)) owner))))
|
|
(t/is (= (:data loaded) (:data (get (cf/all-files live) owner))))
|
|
(t/is (nil? (oracle/check live {})))
|
|
(let [live (await (ftm/run-generated-step live (n/redo)))]
|
|
(t/is (= after (tm/file live)))
|
|
(t/is (= (:data loaded) (:data (get (cf/reference-libraries live (tm/shape-by-id live target)) owner))))
|
|
(t/is (= old-fill (get-in (tm/shape-by-id live (first (:shapes (tm/shape-by-id live control)))) [:fills 0 :fill-color])))
|
|
(t/is (nil? (oracle/check live {})))
|
|
(t/is (empty? (uc/failures (await (ftm/finish-generated live)))))))
|
|
(ftm/uninstall!)))))))
|
|
|
|
(t/deftest ^:async selective-library-reset-replays-through-undo-and-redo
|
|
(await (replay {:world [0 0 {:library true :library-depth 0 :stale-libraries true}]
|
|
:ops [[:library-edit 0 0 1] [:reset 0] [:undo] [:redo]]})))
|
|
|
|
(t/deftest ^:async selective-library-swap-and-switch-replay-through-undo-and-redo
|
|
(doseq [kind [:swap :switch]]
|
|
(let [world [0 0 {:library true :library-depth 0 :library-variants true :stale-libraries true}]
|
|
initial (cg/world world)
|
|
resolved (cg/resolve-op initial {} [kind 0])
|
|
main (get-in resolved [:destination :id])
|
|
index (first (filter #(= main (get-in (cg/resolve-op initial {} [:library-edit % 0 2]) [:shape :parent-id]))
|
|
(range 3)))]
|
|
(t/is (some? index))
|
|
(await (replay {:world world
|
|
:ops [[:library-edit index 0 2] [kind 0] [:undo] [:redo]]})))))
|
|
|
|
(t/deftest ^:async a-selective-library-reset-in-a-main-refreshes-its-local-images
|
|
(let [world [1 0 {:library true :library-depth 0 :stale-libraries true}]
|
|
state (-> (cg/initial-state world) (cg/step [:nest 0]) cg/settle-state)
|
|
initial (:situation state)
|
|
owner (:library-id (cg/resolve-op initial {} [:library-edit 0 0 1]))
|
|
count (:opportunities (cg/resolve-op initial {} [:reset 0]))
|
|
index (first (filter (fn [index]
|
|
(let [shape (:shape (cg/resolve-op initial {} [:reset index]))]
|
|
(and (= owner (:component-file shape))
|
|
(:main-instance (tm/shape-by-id initial (:parent-id shape))))))
|
|
(range count)))]
|
|
(t/is (some? index))
|
|
(await (replay {:world world
|
|
:ops [[:nest 0] [:library-edit 0 0 1] [:reset index] [:undo] [:redo]]}))))
|
|
|
|
(t/deftest ^:async no-op-variant-requests-keep-stale-reference-inputs
|
|
(doseq [request [:current :missing]]
|
|
(await
|
|
(mock/with-mocks* {rp/cmd! mock/rpc-cmd-mock rx/timer mock/timer-mock}
|
|
(let [initial (cg/world [0 0 {:library true :library-depth 0 :library-variants true :stale-libraries true}])
|
|
resolved (cg/resolve-op initial {} [:switch 0])
|
|
shape (:shape resolved)
|
|
target (:id shape)
|
|
owner (:component-file shape)
|
|
source (get (cf/all-files initial) owner)
|
|
main (tm/shape-by-id (tm/with-file initial source) (:shape-ref shape))
|
|
child (first (:shapes main))
|
|
value (if (= request :current)
|
|
(get-in source [:data :components (:component-id shape) :variant-properties 0 :value])
|
|
"missing-variant-value")
|
|
live (ftm/start-generated initial)
|
|
live (await (ftm/run-generated-source-step live owner
|
|
(n/change-property (constantly child) :fills "#00ff00")))
|
|
before (tm/file live)
|
|
inputs (cf/reference-libraries live (tm/shape-by-id live target))
|
|
live (await (ftm/run-generated-step live (n/switch-variant (constantly target) value)))]
|
|
(t/is (= before (tm/file live)))
|
|
(t/is (= inputs (cf/reference-libraries live (tm/shape-by-id live target))))
|
|
(t/is (nil? (oracle/check live {})))
|
|
(t/is (empty? (uc/failures (await (ftm/finish-generated live)))))
|
|
(ftm/uninstall!))))))
|
|
|
|
(t/deftest ^:async reference-only-library-acceptance-keeps-the-older-undo-journal
|
|
(await
|
|
(mock/with-mocks* {rp/cmd! mock/rpc-cmd-mock rx/timer mock/timer-mock}
|
|
(let [initial (cg/world [0 0 {:library true :library-depth 0 :stale-libraries true}])
|
|
owner (n/library-id initial)
|
|
source (cths/add-sample-shape (get (cf/all-files initial) owner) :journal-unrelated)
|
|
extra (:id (cths/get-shape source :journal-unrelated))
|
|
initial (-> initial
|
|
(tm/with-file (cths/add-sample-shape (tm/file initial) :journal-local))
|
|
(tm/with-aux-files {owner source})
|
|
cf/freeze-libraries)
|
|
local (:id (cths/get-shape (tm/file initial) :journal-local))
|
|
copy (first (for [{:keys [shape]} (cg/tree initial)
|
|
:when (= owner (:component-file shape))]
|
|
(:id shape)))
|
|
live (ftm/start-generated initial)
|
|
live (await (ftm/run-generated-step live (n/change-property (constantly local) :opacity 0.4)))
|
|
live (await (ftm/run-generated-source-step live owner
|
|
(n/change-property (constantly extra) :opacity 0.7)))
|
|
loaded (get (cf/all-files live) owner)
|
|
before (tm/file live)
|
|
history (:workspace-undo @st/state)
|
|
journal (::ftm/reference-history live)
|
|
live (await (ftm/run-generated-step live (n/sync-from-library owner)))]
|
|
(t/is (some? local))
|
|
(t/is (some? copy))
|
|
(t/is (not= (:data source) (:data loaded)))
|
|
(t/is (= before (tm/file live)))
|
|
(t/is (= history (:workspace-undo @st/state)))
|
|
(t/is (= journal (::ftm/reference-history live)))
|
|
(t/is (= (:data loaded) (:data (get (cf/reference-libraries live (tm/shape-by-id live copy)) owner))))
|
|
(let [live (await (ftm/run-generated-step live (n/undo)))]
|
|
(t/is (nil? (:opacity (tm/shape-by-id live local))))
|
|
(t/is (= (:data loaded) (:data (get (cf/reference-libraries live (tm/shape-by-id live copy)) owner))))
|
|
(let [live (await (ftm/run-generated-step live (n/redo)))]
|
|
(t/is (= before (tm/file live)))
|
|
(t/is (= (:data loaded) (:data (get (cf/reference-libraries live (tm/shape-by-id live copy)) owner))))
|
|
(t/is (nil? (oracle/check live {})))
|
|
(t/is (empty? (uc/failures (await (ftm/finish-generated live)))))))
|
|
(ftm/uninstall!)))))
|
|
|
|
(t/deftest ^:async library-acceptance-at-the-history-limit-keeps-its-reference-journal
|
|
(await
|
|
(mock/with-mocks* {rp/cmd! mock/rpc-cmd-mock rx/timer mock/timer-mock dwu/MAX-UNDO-SIZE 2}
|
|
(let [initial (cg/world [0 0 {:library true :library-depth 0 :stale-libraries true}])
|
|
initial (tm/with-file initial (cths/add-sample-shape (tm/file initial) :journal-local))
|
|
edit (cg/resolve-op initial {} [:library-edit 0 0 1])
|
|
owner (:library-id edit)
|
|
source (get (cf/all-files initial) owner)
|
|
local (:id (cths/get-shape (tm/file initial) :journal-local))
|
|
copy (first (for [{:keys [shape]} (cg/tree initial)
|
|
:when (= owner (:component-file shape))]
|
|
(:id shape)))
|
|
live (ftm/start-generated initial)
|
|
live (await (ftm/run-generated-step live (n/change-property (constantly local) :opacity 0.2)))
|
|
live (await (ftm/run-generated-step live (n/change-property (constantly local) :opacity 0.4)))
|
|
live (await (ftm/run-generated-source-step live owner (:op edit)))
|
|
loaded (get (cf/all-files live) owner)
|
|
before (tm/file live)
|
|
history (:workspace-undo @st/state)
|
|
live (await (ftm/run-generated-step live (n/sync-from-library owner)))
|
|
after (tm/file live)
|
|
current (:workspace-undo @st/state)]
|
|
(t/is (= 2 (count (:items history)) (count (:items current))))
|
|
(t/is (= (:index history) (:index current)))
|
|
(t/is (not= (:undo-group (peek (:items history))) (:undo-group (peek (:items current)))))
|
|
(t/is (not= (:data before) (:data after)))
|
|
(t/is (= (:data loaded) (:data (get (cf/reference-libraries live (tm/shape-by-id live copy)) owner))))
|
|
(let [live (await (ftm/run-generated-step live (n/undo)))]
|
|
(t/is (= before (tm/file live)))
|
|
(t/is (= (:data source) (:data (get (cf/reference-libraries live (tm/shape-by-id live copy)) owner))))
|
|
(let [live (await (ftm/run-generated-step live (n/redo)))]
|
|
(t/is (= after (tm/file live)))
|
|
(t/is (= (:data loaded) (:data (get (cf/reference-libraries live (tm/shape-by-id live copy)) owner))))
|
|
(t/is (nil? (oracle/check live {})))
|
|
(t/is (empty? (uc/failures (await (ftm/finish-generated live)))))))
|
|
(ftm/uninstall!)))))
|
|
|
|
(t/deftest ^:async accepted-source-child-undo-keeps-backend-parity
|
|
(await (replay {:world [0 0 {:library true :library-depth 0 :library-grid true :stale-libraries true}]
|
|
:ops [[:library-add-child 0] [:library-add-child 0] [:library-sync]
|
|
[:library-undo 0] [:undo] [:library-redo 0] [:redo]]})))
|
|
|
|
(t/deftest ^:async transitive-library-acceptance-keeps-each-editors-reference-history
|
|
(await (replay {:world [0 0 {:library true :library-depth 0 :library-dependency true :stale-libraries true}]
|
|
:ops [[:library-edit 1 0 1] [:library-sync 0] [:library-accept 0]
|
|
[:library-sync 0] [:library-undo 0] [:undo]
|
|
[:library-redo 0] [:redo]]})))
|
|
|
|
(t/deftest ^:async a-source-undo-retains-the-consumers-accepted-child-reference
|
|
(await
|
|
(mock/with-mocks* {rp/cmd! mock/rpc-cmd-mock rx/timer mock/timer-mock}
|
|
(let [world [0 0 {:library true :library-depth 0 :library-grid true :stale-libraries true}]
|
|
ops [[:library-add-child 0] [:library-add-child 0] [:library-sync]]
|
|
initial (cg/world world)
|
|
resolved (cg/resolve-op initial {} (first ops))
|
|
owner (:library-id resolved)
|
|
main-id (get-in resolved [:shape :id])
|
|
live (loop [live (ftm/start-generated initial) tuples ops]
|
|
(if-let [tuple (first tuples)]
|
|
(let [{:keys [op library-id]} (cg/resolve-op live {} tuple)]
|
|
(recur (if library-id
|
|
(await (ftm/run-generated-source-step live library-id op))
|
|
(await (ftm/run-generated-step live op)))
|
|
(rest tuples)))
|
|
live))
|
|
source (get (cf/all-files live) owner)
|
|
ids (:shapes (tm/shape-by-id (tm/with-file live source) main-id))
|
|
before (tm/file live)
|
|
live (await (ftm/run-generated-source-step live owner (n/undo)))
|
|
source (get (cf/all-files live) owner)
|
|
current (:shapes (tm/shape-by-id (tm/with-file live source) main-id))]
|
|
(t/is (= 5 (count ids)))
|
|
(t/is (= 4 (count current)))
|
|
(t/is (= before (tm/file live)))
|
|
(doseq [{:keys [shape]} (cg/tree live) :when (= main-id (:shape-ref shape))]
|
|
(let [accepted (get (cf/reference-libraries live shape) owner)]
|
|
(t/is (= ids (:shapes (tm/shape-by-id (tm/with-file live accepted) main-id))))))
|
|
(t/is (nil? (oracle/check live {})))
|
|
(t/is (= [] (vec (for [file (vals (oracle/canonical live))
|
|
objects (cf/object-trees file)
|
|
shape (vals objects)
|
|
:when (uuid? (:shape-ref shape))]
|
|
(:shape-ref shape)))))
|
|
(t/is (empty? (uc/failures (await (ftm/finish-generated live)))))
|
|
(ftm/uninstall!)))))
|
|
|
|
(t/deftest ^:async update-main-refreshes-library-reference-inputs-through-undo-and-redo
|
|
(await (replay {:world [0 0 {:library true :library-depth 0 :stale-libraries true}]
|
|
:ops [[:edit 0 1 1 2] [:update-main 0] [:undo] [:redo]]})))
|
|
|
|
(t/deftest ^:async update-main-reference-history-follows-source-and-consumer-edits
|
|
(doseq [depth [0 1]
|
|
grid [false true]
|
|
accept [false true]]
|
|
(await (replay {:world [1 0 {:library true :library-depth depth :library-grid grid :stale-libraries true}]
|
|
:ops (vec (concat [[:library-edit 0 0 1]]
|
|
(when accept [[:library-sync]])
|
|
[[:edit 0 1 1 2] [:update-main 0] [:undo] [:redo]
|
|
[:library-edit 0 0 2] [:library-undo 0] [:library-redo 0]]))}))))
|
|
|
|
(t/deftest ^:async update-main-keeps-unrelated-library-components-stale
|
|
(await
|
|
(mock/with-mocks* {rp/cmd! mock/rpc-cmd-mock rx/timer mock/timer-mock}
|
|
(let [initial (cg/world [0 0 {:library true :library-depth 0 :library-variants true :stale-libraries true}])
|
|
target (get-in (cg/resolve-op initial {} [:edit 0 1 1 2]) [:shape :id])
|
|
head (tm/shape-by-id initial target)
|
|
owner (:component-file head)
|
|
source (get (cf/all-files initial) owner)
|
|
main (:shape-ref head)
|
|
sibling (first (for [{:keys [shape]} (cg/tree initial)
|
|
:when (and (= main (:shape-ref shape)) (not= target (:id shape)))]
|
|
(:id shape)))
|
|
unrelated (first (for [{:keys [shape]} (cg/tree (tm/with-file initial source))
|
|
:when (and (:main-instance shape) (not= main (:id shape)))]
|
|
(:id shape)))
|
|
control (first (for [{:keys [shape]} (cg/tree initial)
|
|
:when (= unrelated (:shape-ref shape))]
|
|
(:id shape)))
|
|
child (first (:shapes (tm/shape-by-id (tm/with-file initial source) unrelated)))
|
|
old-fill (get-in (tm/shape-by-id initial (first (:shapes (tm/shape-by-id initial control))))
|
|
[:fills 0 :fill-color])
|
|
live (ftm/start-generated initial)
|
|
live (await (ftm/run-generated-source-step live owner
|
|
(n/change-property (constantly child) :fills "#00ff00")))
|
|
live (await (ftm/run-generated-step live (n/change-property (constantly target) :opacity 0.4)))
|
|
before (ftm/snapshot)
|
|
prior (cf/reference-libraries live (tm/shape-by-id live target))
|
|
live (await (ftm/run-generated-step live (n/update-main (constantly target))))
|
|
after (ftm/snapshot)
|
|
updated (get (cf/all-files live) owner)]
|
|
(t/is (some? sibling))
|
|
(t/is (some? control))
|
|
(t/is (= 0.4 (:opacity (tm/shape-by-id (tm/with-file live updated) main))))
|
|
(doseq [id [target sibling]]
|
|
(t/is (= 0.4 (:opacity (tm/shape-by-id live id))))
|
|
(t/is (= (:data updated) (:data (get (cf/reference-libraries live (tm/shape-by-id live id)) owner)))))
|
|
(t/is (= "#00ff00" (get-in (tm/shape-by-id (tm/with-file live updated) child) [:fills 0 :fill-color])))
|
|
(t/is (= old-fill (get-in (tm/shape-by-id live (first (:shapes (tm/shape-by-id live control)))) [:fills 0 :fill-color])))
|
|
(t/is (= (:data source) (:data (get (cf/reference-libraries live (tm/shape-by-id live control)) owner))))
|
|
(t/is (nil? (oracle/check live {})))
|
|
(let [live (await (ftm/run-generated-step live (n/undo)))]
|
|
(t/is (= before (ftm/snapshot)))
|
|
(doseq [id [target sibling]]
|
|
(t/is (= (:data (get prior owner))
|
|
(:data (get (cf/reference-libraries live (tm/shape-by-id live id)) owner)))))
|
|
;; The source copy regains its authored opacity on undo.
|
|
(t/is (nil? (oracle/check live {target {:layer-effects-group {:opacity 0.4 :blend-mode nil}}})))
|
|
(let [live (await (ftm/run-generated-step live (n/redo)))]
|
|
(t/is (= after (ftm/snapshot)))
|
|
(doseq [id [target sibling]]
|
|
(t/is (= (:data updated) (:data (get (cf/reference-libraries live (tm/shape-by-id live id)) owner)))))
|
|
(t/is (= (:data source) (:data (get (cf/reference-libraries live (tm/shape-by-id live control)) owner))))
|
|
(t/is (nil? (oracle/check live {})))
|
|
(t/is (empty? (uc/failures (await (ftm/finish-generated live)))))))
|
|
(ftm/uninstall!)))))
|
|
|
|
(t/deftest ^:async source-history-checkpoints-legitimate-consumer-writes
|
|
(await
|
|
(mock/with-mocks* {rp/cmd! mock/rpc-cmd-mock rx/timer mock/timer-mock}
|
|
(t/is (map? (cg/run {:world [0 0 {:library true :library-depth 0 :stale-libraries true}]
|
|
:ops [[:library-edit 0 0 1] [:library-sync] [:edit 0 1 1 2]
|
|
[:update-main 0] [:library-edit 0 0 2]]})))
|
|
(let [initial (cg/world [0 0 {:library true :library-depth 0 :stale-libraries true}])
|
|
edit (cg/resolve-op initial {} [:library-edit 0 0 1])
|
|
owner (:library-id edit)
|
|
child (get-in edit [:shape :id])
|
|
main (get-in edit [:shape :parent-id])
|
|
copy (get-in (cg/resolve-op initial {} [:edit 0 1 1 2]) [:shape :id])
|
|
page-id (cthf/current-page-id (get (cf/all-files initial) owner))
|
|
live (ftm/start-generated initial)
|
|
live (await (ftm/run-generated-source-step live owner (:op edit)))
|
|
entry (get-in live [::ftm/source-editors owner :undo :items 0])
|
|
live (await (ftm/run-generated-step live (n/sync-from-library owner)))
|
|
live (await (ftm/run-generated-step live (n/change-property (constantly copy) :opacity 0.4)))
|
|
live (await (ftm/run-generated-step live (n/update-main (constantly copy))))
|
|
source (get (cf/all-files live) owner)
|
|
_ (t/is (= 0.4 (:opacity (tm/shape-by-id (tm/with-file live source) main))))
|
|
live (await (ftm/run-generated-source-step live owner
|
|
(n/change-property (constantly child) :fills "#00ff00")))
|
|
editor (get-in live [::ftm/source-editors owner])
|
|
base (uc/baseline (:situation editor))
|
|
source (get (cf/all-files live) owner)]
|
|
(t/is (= "#00ff00" (get-in (tm/shape-by-id (tm/with-file live source) child) [:fills 0 :fill-color])))
|
|
(t/is (= 0.4 (:opacity (tm/shape-by-id (tm/with-file live source) main))))
|
|
(t/is (= entry (get-in editor [:undo :items 0])))
|
|
(t/is (= 2 (count (get-in editor [:undo :items]))))
|
|
(t/is (= 0 (:depth base)))
|
|
(t/is (= 0.4 (get-in base [:snapshot :files owner :data :pages-index page-id :objects main :opacity])))
|
|
(t/is (= "#ff0000" (get-in base [:snapshot :files owner :data :pages-index page-id :objects child :fills 0 :fill-color])))
|
|
(t/is (empty? (uc/failures (await (ftm/finish-generated live)))))
|
|
(ftm/uninstall!)))))
|
|
|
|
(t/deftest ^:async source-history-checkpoints-preserve-no-ops-and-older-entries
|
|
(await
|
|
(mock/with-mocks* {rp/cmd! mock/rpc-cmd-mock rx/timer mock/timer-mock}
|
|
(let [initial (cg/world [0 0 {:library true :library-depth 0 :stale-libraries true}])
|
|
edit (cg/resolve-op initial {} [:library-edit 0 0 1])
|
|
owner (:library-id edit)
|
|
child (get-in edit [:shape :id])
|
|
main (get-in edit [:shape :parent-id])
|
|
copy (get-in (cg/resolve-op initial {} [:edit 0 1 1 2]) [:shape :id])
|
|
live (ftm/start-generated initial)
|
|
live (await (ftm/run-generated-source-step live owner (:op edit)))
|
|
live (await (ftm/run-generated-source-step live owner
|
|
(n/change-property (constantly child) :fills "#00ff00")))
|
|
editor (get-in live [::ftm/source-editors owner])
|
|
_ (t/is (= -1 (:depth (uc/baseline (:situation editor)))))
|
|
entries (:items (:undo editor))
|
|
live (await (ftm/run-generated-step live (n/sync-from-library owner)))
|
|
live (await (ftm/run-generated-step live (n/change-property (constantly copy) :opacity 0.4)))
|
|
live (await (ftm/run-generated-step live (n/update-main (constantly copy))))
|
|
base (uc/baseline live)
|
|
live (await (ftm/run-generated-source-step live owner
|
|
(n/change-property (constantly child) :fills "#00ff00")))
|
|
editor (get-in live [::ftm/source-editors owner])]
|
|
(t/is (= base (uc/baseline live)))
|
|
(t/is (= 1 (:depth (uc/baseline (:situation editor)))))
|
|
(t/is (= entries (:items (:undo editor))))
|
|
(t/is (empty? (uc/failures (await (ftm/finish-generated live)))))
|
|
(let [live (loop [live live steps [[(n/undo) "#ff0000"] [(n/undo) "#abcdef"]
|
|
[(n/redo) "#ff0000"] [(n/redo) "#00ff00"]]]
|
|
(if-let [[op fill] (first steps)]
|
|
(let [live (await (ftm/run-generated-source-step live owner op))
|
|
source (tm/with-file live (get (cf/all-files live) owner))]
|
|
(t/is (= fill (get-in (tm/shape-by-id source child) [:fills 0 :fill-color])))
|
|
(t/is (= 0.4 (:opacity (tm/shape-by-id source main))))
|
|
(recur live (rest steps)))
|
|
live))
|
|
live (await (ftm/run-generated-step live (n/undo)))
|
|
_ (t/is (nil? (:opacity (tm/shape-by-id (tm/with-file live (get (cf/all-files live) owner)) main))))
|
|
live (await (ftm/run-generated-step live (n/redo)))
|
|
file (tm/with-file live (get (cf/all-files live) owner))]
|
|
(t/is (= 0.4 (:opacity (tm/shape-by-id file main))))
|
|
(t/is (= "#00ff00" (get-in (tm/shape-by-id file child) [:fills 0 :fill-color])))
|
|
(t/is (empty? (uc/failures (await (ftm/finish-generated live))))))
|
|
(ftm/uninstall!)))))
|
|
|
|
(t/deftest ^:async source-handoff-reports-and-retains-a-broken-consumer-segment
|
|
(await
|
|
(mock/with-mocks* {rp/cmd! mock/rpc-cmd-mock rx/timer mock/timer-mock}
|
|
(let [initial (cg/world [0 0 {:library true :library-depth 0 :stale-libraries true}])
|
|
edit (cg/resolve-op initial {} [:library-edit 0 0 1])
|
|
owner (:library-id edit)
|
|
copy (get-in (cg/resolve-op initial {} [:edit 0 1 1 2]) [:shape :id])
|
|
file-id (:id (tm/file initial))
|
|
page-id (cthf/current-page-id (tm/file initial))
|
|
live (ftm/start-generated initial)
|
|
live (await (ftm/run-generated-step live (n/change-property (constantly copy) :opacity 0.4)))
|
|
base (uc/baseline live)
|
|
;; Corrupt the expected pre-edit state. Handoff must report this
|
|
;; whole-segment failure before a source edit advances the baseline.
|
|
live (uc/mark-baseline live (:depth base)
|
|
(assoc-in (:snapshot base)
|
|
[:files file-id :data :pages-index page-id :objects copy :opacity] 0.9))
|
|
reports (atom [])
|
|
live (await (mock/with-mocks* {t/report #(swap! reports conj %)}
|
|
(ftm/run-generated-source-step live owner (:op edit))))
|
|
failed (filter #(= :fail (:type %)) @reports)
|
|
errors (filter #(= :error (:type %)) @reports)]
|
|
(t/is (= 1 (count failed)))
|
|
(t/is (empty? errors))
|
|
(t/is (= [:variant-undo] (mapv :phase (uc/failures live))))
|
|
(t/is (= #{[:file :file1 :object :random-library-copy-0-0 :opacity]}
|
|
(:signature (first (uc/failures live)))))
|
|
(t/is (= 0 (:depth (uc/baseline live))))
|
|
(ftm/uninstall!)))))
|
|
|
|
(t/deftest ^:async source-editors-retain-their-own-undo-and-redo-histories
|
|
(doseq [ops [[[:library-add-child 0] [:library-add-child 0] [:library-undo 0]
|
|
[:edit 0 1 1 2] [:library-redo 0] [:undo] [:redo]]
|
|
[[:edit 0 1 1 2] [:library-edit 0 0 1] [:undo]
|
|
[:library-undo 0] [:redo] [:library-redo 0]]
|
|
[[:library-transform 0 0 1 0] [:edit 0 1 1 2]
|
|
[:library-undo 0] [:undo] [:library-redo 0] [:redo]]]]
|
|
(await (replay {:world [1 0 {:library true :library-depth 0 :library-grid true :stale-libraries true}]
|
|
:ops ops}))))
|
|
|
|
(t/deftest ^:async two-source-editors-keep-their-histories-separate
|
|
(await (replay {:world [1 0 {:library true :library-depth 0 :library-dependency true :stale-libraries true}]
|
|
:ops [[:library-edit 0 0 1] [:library-edit 1 0 2]
|
|
[:library-undo 0] [:library-undo 1]
|
|
[:library-redo 0] [:library-redo 1]]})))
|
|
|
|
(t/deftest ^:async source-grid-acceptance-preserves-authored-cells-and-undo
|
|
(await
|
|
(mock/with-mocks* {rp/cmd! mock/rpc-cmd-mock rx/timer mock/timer-mock}
|
|
(let [initial (cg/world [1 0 {:library true :library-depth 0 :library-grid true :stale-libraries true}])
|
|
edit (cg/resolve-op initial {} [:grid-cell 0 0 0 2])
|
|
id (get-in edit [:shape :id])
|
|
props (get-in edit [:op :value :props])
|
|
live (ftm/start-generated initial)
|
|
live (await (ftm/run-generated-step live (:op edit)))
|
|
live (loop [live live tuples [[:library-add-child 0] [:library-add-child 0] [:edit 0 1 1 2]]]
|
|
(if-let [tuple (first tuples)]
|
|
(let [{:keys [op library-id]} (cg/resolve-op live {} tuple)
|
|
after (if library-id
|
|
(await (ftm/run-generated-source-step live library-id op))
|
|
(await (ftm/run-generated-step live op)))]
|
|
(recur after (rest tuples)))
|
|
live))
|
|
live (await (ftm/run-generated-step live (:op (cg/resolve-op live {} [:library-sync]))))
|
|
shape (tm/shape-by-id live id)
|
|
cell (first (filter #(= [1 1] [(:row %) (:column %)]) (vals (:layout-grid-cells shape))))]
|
|
(t/is (some? (cthf/validate-file! (tm/file live) (cf/libraries live))))
|
|
(t/is (= 5 (count (:shapes shape))))
|
|
(t/is (= [2 3] (mapv #(count (get shape %)) [:layout-grid-rows :layout-grid-columns])))
|
|
(t/is (= props (select-keys cell (keys props))))
|
|
(t/is (empty? (uc/failures (await (ftm/finish-generated live)))))
|
|
(ftm/uninstall!)))))
|
|
|
|
(t/deftest ^:async authored-grid-histories-use-independent-cell-expectations
|
|
(doseq [ops [[[:grid-direction 0 0 1 1] [:grid-direction 0 0 1 0]
|
|
[:grid-direction 0 0 0 0] [:update-main 0]
|
|
[:grid-direction 0 0 0 1] [:reset 0] [:undo] [:redo]]
|
|
[[:grid-cell 0 0 0 1] [:grid-cell 0 1 1 0] [:grid-cell 0 0 2 0]
|
|
[:update-main 0] [:grid-cell 0 1 2 1] [:reset 0] [:undo] [:redo]]
|
|
[[:grid-cell 0 0 0 1] [:duplicate 0] [:undo] [:redo] [:update-main 0]]
|
|
[[:grid-direction 0 0 1 1] [:add-child 0] [:undo] [:redo]]
|
|
[[:grid-cell 0 0 0 1] [:remove-child 0] [:undo] [:redo]]
|
|
[[:grid-cell 0 0 0 1] [:detach 0] [:undo] [:redo]]]]
|
|
(await (replay {:world [1 0 {:layout :grid :layout-children true :grid-square true}] :ops ops}))))
|
|
|
|
(t/deftest ^:async detaching-an-outer-copy-remaps-inherited-grid-cell-intent
|
|
(await (replay {:world [1 1 {:layout :grid :layout-children true :grid-square true}]
|
|
:ops [[:grid-cell 0 0 0 1] [:detach 0] [:undo] [:redo]]})))
|
|
|
|
(t/deftest ^:async layout-container-histories-survive-component-operations
|
|
(doseq [[property layouts] [[20 [:flex]] [21 [:flex]] [22 [:flex :grid]] [23 [:flex :grid]]
|
|
[24 [:flex :grid]] [25 [:flex :grid]] [26 [:grid]]]
|
|
layout layouts]
|
|
(await (replay {:world [1 0 {:layout layout :layout-children true}]
|
|
:ops [[:style 0 property 1 1] [:style 0 property 1 0]
|
|
[:style 0 property 0 0] [:undo] [:redo] [:update-main 0]
|
|
[:style 0 property 0 1] [:reset 0]
|
|
[:style 0 property 0 1] [:detach 0] [:undo] [:redo]]}))))
|
|
|
|
(t/deftest ^:async layout-item-histories-survive-component-operations
|
|
(doseq [property (range 27 37)
|
|
layout (if (= property 28) [:flex] [:flex :grid])]
|
|
(let [authored (if (= property 27) 0 1)
|
|
other (if (= property 27) 1 0)]
|
|
(await (replay {:world [1 0 {:layout layout :layout-children true :layout-item-margins true}]
|
|
:ops [[:style 0 property authored 1] [:style 0 property authored 0]
|
|
[:style 0 property other 0] [:undo] [:redo] [:update-main 0]
|
|
[:style 0 property other 1] [:reset 0]
|
|
[:style 0 property other 1] [:detach 0] [:undo] [:redo]]})))))
|
|
|
|
(t/deftest ^:async hug-sizing-histories-survive-component-operations
|
|
(doseq [property [29 30] layout [:flex :grid]]
|
|
(await (replay {:world [1 0 {:layout layout :layout-children true :layout-copies true}]
|
|
:ops [[:style 0 property 2 1] [:style 0 property 2 0] [:undo] [:redo]
|
|
[:style 0 property 0 0] [:update-main 0]
|
|
[:style 0 property 2 1] [:reset 0]
|
|
[:style 0 property 2 1] [:detach 0] [:undo] [:redo]]}))))
|
|
|
|
(t/deftest ^:async adding-a-flex-child-before-making-a-copy-child-absolute-stays-settled
|
|
(await (replay {:world [1 0 {:layout :flex :layout-children true}]
|
|
:ops [[:add-child 0] [:style 2 35 1 1] [:undo] [:redo]]})))
|
|
|
|
(t/deftest ^:async nesting-a-copy-alongside-a-hidden-layout-child-stays-settled
|
|
(await (replay {:world [3 0 {:text true :text-styles true :layout :flex}]
|
|
:ops [[:delete 9 9 1 2] [:text 5 9 1 3] [:style 3 1 1]
|
|
[:restore 5 8 1 6] [:nest 5 6 0 2] [:undo] [:redo]]})))
|
|
|
|
(t/deftest ^:async generated-effects-and-corners-survive-component-operations
|
|
(doseq [property (range 14 20)]
|
|
(await (replay {:world [2 1 {:variants true :rich-variants true}]
|
|
:ops [[:style 0 property 1 1] [:style 1 property 1 0]
|
|
[:undo] [:redo] [:update-main 0]
|
|
[:style 0 property 0 1] [:reset 0]
|
|
[:style 0 property 1 1] [:detach 0]
|
|
[:undo] [:redo]]}))))
|
|
|
|
(t/deftest ^:async swapping-a-copy-with-authored-position-constraints-stays-settled
|
|
(await (replay {:world [2 1 {:library true :variants true :rich-variants true
|
|
:text true :text-styles true :layout :flex :layout-copies true}]
|
|
:ops [[:style 12 9 11 6] [:delete 10 14 10 12] [:swap 17 2 14 5]
|
|
[:undo] [:redo]]})))
|
|
|
|
(t/deftest ^:async accepting-a-library-does-not-record-equal-numeric-geometry
|
|
(await (replay {:world [2 1 {:library true :variants true}]
|
|
:ops [[:resize 10 2 2 10] [:library-sync 3 1 2 8]
|
|
[:undo] [:redo]]})))
|
|
|
|
(t/deftest ^:async nesting-a-swapped-copy-in-a-blocked-main-authors-its-lock
|
|
(await (replay {:world [2 0 {:library true :variants true :rich-variants true
|
|
:text true :text-styles true :layout nil :layout-copies true}]
|
|
:ops [[:style 3 2 1] [:swap 0 0 0 0] [:nest 0 0 0 0]
|
|
[:undo] [:redo]]})))
|
|
|
|
(t/deftest ^:async detaching-a-rotated-switched-copy-keeps-nested-placement-stable
|
|
(await (replay {:world [2 0 {:library true :variants true :rich-variants true
|
|
:text true :text-styles true :layout nil :layout-copies true}]
|
|
:ops [[:duplicate 1 0 0 0] [:duplicate 1 0 0 0] [:switch 3 0 0 0]
|
|
[:rotate 5 0 0 0] [:detach 5 0 0 0]
|
|
[:undo] [:undo] [:undo] [:undo] [:undo]
|
|
[:redo] [:redo] [:redo] [:redo] [:redo]]})))
|
|
|
|
(t/deftest ^:async geometry-actions-replay-on-mains-and-copy-descendants
|
|
(doseq [action (range 6) scope (range 5)]
|
|
(await (replay {:world [2 2]
|
|
:ops [[:transform 0 action 3 scope] [:undo] [:redo]]}))))
|
|
|
|
(t/deftest ^:async text-style-units-replay-through-editor-commits
|
|
(doseq [unit (range 12)]
|
|
(await (replay {:world [2 1 {:text true :text-styles true}]
|
|
:ops [[:text-style 1 unit 1] [:undo] [:redo]]}))))
|
|
|
|
(t/deftest ^:async reflecting-a-rotated-copy-settles-descendant-flips
|
|
(await (replay {:world [2 1 {:text true :layout :grid}]
|
|
:ops [[:rotate 1] [:transform 2 16 0 9]]})))
|
|
|
|
(t/deftest ^:async swapping-after-a-resized-variant-keeps-child-placement
|
|
(await (replay {:world [2 2 {:variants true :variant-diff false :rich-variants true
|
|
:text true :layout nil :layout-copies true}]
|
|
:ops [[:resize 0] [:switch 0] [:swap 0]]})))
|
|
|
|
(t/deftest ^:async switching-after-a-main-move-and-child-removal-stays-settled
|
|
(await (replay {:world [2 0 {:library true :variants true :rich-variants true :text true
|
|
:layout :flex :layout-copies true}]
|
|
:ops [[:delete 0] [:restore 0] [:transform 4 0 0 0] [:remove-child 8]
|
|
[:style 5 7 0 0] [:switch 4] [:rotate 0 2 0 0]]})))
|
|
|
|
(t/deftest ^:async reflecting-a-rotated-nested-copy-settles-descendant-flips
|
|
(await (replay {:world [2 1 {:text true :layout :grid}]
|
|
:ops [[:nest 11] [:rotate 1] [:transform 2 16 0 18]]})))
|
|
|
|
(t/deftest ^:async detach-keeps-an-authored-swap-inside-a-surviving-copy
|
|
(await (replay {:world [2 2 {:variants true :variant-diff false}]
|
|
:ops [[:switch 10] [:switch 0] [:detach 2]]})))
|
|
|
|
(t/deftest ^:async seeded-programs-replay-through-the-frontend
|
|
(doseq [seed [712 20261022 1792691]]
|
|
(await (replay (gen/generate cg/program-gen 20 seed)))))
|
|
|
|
(t/deftest ^:async detach-undo-shrunk-regression
|
|
(await (replay {:world [2 0] :ops [[:edit 0 0 1 1] [:detach 0] [:undo] [:redo]]})))
|
|
|
|
(t/deftest ^:async structure-programs-replay-through-the-frontend
|
|
(doseq [seed [712 20261022]]
|
|
(await (replay (gen/generate cg/structure-program-gen 10 seed)))))
|
|
|
|
(t/deftest ^:async moving-a-copy-child-uses-its-own-pre-edit-frame
|
|
(await (replay {:world [2 1]
|
|
:ops [[:transform 0 3 0 2] [:transform 0 0 2 2] [:undo] [:redo]]})))
|
|
|
|
(t/deftest ^:async nested-text-rotation-shrunk-regression
|
|
(await (replay {:world [2 0 {:text true}]
|
|
:ops [[:nest 0] [:detach 0] [:rotate 0]]})))
|
|
|
|
(t/deftest ^:async nesting-restores-default-constraints-on-undo
|
|
(await (replay {:world [2 0] :ops [[:nest 0]]})))
|
|
|
|
(t/deftest ^:async swap-programs-replay-through-the-frontend
|
|
(doseq [seed [712 20261022]]
|
|
(await (replay (gen/generate cg/swap-program-gen 5 seed)))))
|
|
|
|
(t/deftest ^:async variant-programs-replay-through-the-frontend
|
|
(doseq [seed [712 20261022]]
|
|
(await (replay (gen/generate cg/variant-program-gen 5 seed)))))
|
|
|
|
(t/deftest ^:async library-programs-replay-through-the-frontend
|
|
(await (replay {:world [2 1 {:library true :variants true}]
|
|
:ops [[:edit 0 0 1 2] [:update-main 0] [:library-sync]
|
|
[:undo] [:redo] [:sync 1]]}))
|
|
(await (replay (gen/generate cg/library-program-gen 5 712))))
|
|
|
|
(t/deftest ^:async inherited-rotation-switch-shrunk-regression
|
|
(await (replay {:world [2 1 {:library true :variants true}]
|
|
:ops [[:edit 0 0 1 2] [:update-main 0] [:library-sync]
|
|
[:undo] [:redo] [:reset 0] [:sync 1]
|
|
[:rotate 0 0 0 0] [:switch 1 0 0 0]]})))
|
|
|
|
(t/deftest ^:async swapped-subtree-update-main-shrunk-regression
|
|
(await (replay {:world [2 1 {:library true :variants true}]
|
|
:ops [[:edit 0 0 1 2] [:update-main 0] [:library-sync]
|
|
[:undo] [:redo] [:reset 0] [:sync 1]
|
|
[:resize 0 0 0 0] [:duplicate 0 0 0 0]
|
|
[:switch 2 0 0 0] [:update-main 2 0 0 0]]})))
|
|
|
|
(t/deftest ^:async main-head-detach-shrunk-regression
|
|
(await (replay {:world [2 1 {:library true :variants true}]
|
|
:ops [[:edit 0 0 1 2] [:update-main 0] [:library-sync]
|
|
[:undo] [:redo] [:reset 0] [:sync 1]
|
|
[:switch 1 0 0 0] [:detach 0 0 0 0] [:delete 0 0 0 0]]})))
|
|
|
|
(t/deftest ^:async partial-sync-geometry-boundary-shrunk-regression
|
|
(await (replay {:world [2 0 {:text true :layout nil}]
|
|
:ops [[:add-child 0] [:remove-child 0] [:duplicate 0] [:nest 0]
|
|
[:delete 0] [:restore 0] [:text 0 0 1] [:text 1 1 1]
|
|
[:resize 0 0 2] [:rotate 0 0 0] [:reset 0]
|
|
[:edit 0 0 1 1] [:update-main 0] [:sync 1]
|
|
[:detach 0] [:undo] [:redo] [:undo 0 0 0 0]
|
|
[:add-child 17 0 0 0] [:rotate 19 0 0 0] [:undo 0 0 0 0]]})))
|
|
|
|
(t/deftest ^:async update-main-after-nesting-a-rotated-text-copy-undoes-together
|
|
(await (replay {:world [2 0 {:text true}]
|
|
:ops [[:duplicate 0] [:nest 0] [:rotate 0 0 0]
|
|
[:edit 0 0 1 1] [:update-main 0]]})))
|
|
|
|
(t/deftest ^:async updating-main-then-swapping-a-child-restores-parent-state
|
|
(await (replay {:world [2 1 {:library true :variants true}]
|
|
:ops [[:edit 0 0 1 2] [:update-main 0] [:library-sync]
|
|
[:undo] [:redo] [:reset 0] [:sync 1]
|
|
[:switch 5 0 0 0] [:update-main 0 0 0 0] [:swap 13 0 0 0]]})))
|
|
|
|
(t/deftest ^:async swapping-main-subtrees-with-several-children-undoes-their-order
|
|
(await (replay {:world [2 2 {:variants true :variant-diff false}]
|
|
:ops [[:edit 0 0 1 1] [:switch 0] [:switch 0] [:swap 0]
|
|
[:undo] [:redo] [:reset 0] [:edit 0 1 1 1]
|
|
[:update-main 0] [:sync 1] [:add-child 1 0 0 0]
|
|
[:add-child 1 0 0 0] [:add-child 1 0 0 0]
|
|
[:swap 0 0 0 0] [:swap 0 0 0 0] [:text 0 0 0 0]]})))
|
|
|
|
(t/deftest ^:async updating-a-rotated-outer-main-composes-authored-child-orientation
|
|
(await (replay {:world [2 0 {:text true :layout nil}]
|
|
:ops [[:add-child 0] [:remove-child 0] [:duplicate 0] [:nest 0]
|
|
[:delete 0] [:restore 0] [:text 0 0 1] [:text 1 1 1]
|
|
[:resize 0 0 2] [:rotate 0 0 0] [:reset 0]
|
|
[:edit 0 0 1 1] [:update-main 0] [:sync 1]
|
|
[:detach 0] [:undo] [:redo] [:duplicate 0 0 0 0]
|
|
[:resize 0 0 0 0] [:nest 0 0 0 0] [:rotate 4 0 0 0]
|
|
[:detach 3 0 0 0] [:update-main 4 0 0 0]]})))
|
|
|
|
(t/deftest ^:async updating-a-duplicated-switched-copy-restores-the-main-order
|
|
(await (replay {:world [2 1 {:library true :variants true}]
|
|
:ops [[:edit 0 0 1 2] [:update-main 0] [:library-sync]
|
|
[:undo] [:redo] [:reset 0] [:sync 1]
|
|
[:switch 1 0 0 0] [:duplicate 0 0 0 0]
|
|
[:update-main 0 0 0 0] [:redo 0 0 0 0]]})))
|
|
|
|
(t/deftest ^:async switching-a-detached-rotated-copy-keeps-its-resize
|
|
(await (replay {:world [2 1 {:library true :variants true}]
|
|
:ops [[:edit 0 0 1 2] [:update-main 0] [:library-sync]
|
|
[:undo] [:redo] [:reset 0] [:sync 1]
|
|
[:rotate 1 0 0 0] [:detach 1 0 0 0]
|
|
[:detach 2 0 0 0] [:resize 2 0 0 0] [:switch 2 0 0 0]]})))
|
|
|
|
(t/deftest ^:async minimum-size-parent-orientation-does-not-amplify-oracle-drift
|
|
(await (replay {:world [3 0 {:text true :layout nil}]
|
|
:ops [[:add-child 0] [:remove-child 0] [:duplicate 0] [:nest 0]
|
|
[:delete 0] [:restore 0] [:text 0 0 1] [:text 1 1 1]
|
|
[:resize 0 0 2] [:rotate 0 0 0] [:reset 0]
|
|
[:edit 0 0 1 1] [:update-main 0] [:sync 1]
|
|
[:detach 0] [:undo] [:redo] [:edit 4 0 0 0]
|
|
[:duplicate 3 0 0 0] [:nest 10 0 0 0] [:rotate 9 0 0 0]
|
|
[:update-main 7 0 0 0] [:delete 0 0 0 0]]})))
|
|
|
|
(t/deftest ^:async detaching-a-rotated-parent-inherits-geometry-in-the-copy-frame
|
|
(await (replay {:world [2 0 {:text true :layout nil}]
|
|
:ops [[:add-child 0] [:remove-child 0] [:duplicate 0] [:nest 0]
|
|
[:delete 0] [:restore 0] [:text 0 0 1] [:text 1 1 1]
|
|
[:resize 0 0 2] [:rotate 0 0 0] [:reset 0]
|
|
[:edit 0 0 1 1] [:update-main 0] [:sync 1]
|
|
[:detach 0] [:undo] [:redo] [:resize 0 0 0 0]
|
|
[:delete 0 0 0 0] [:rotate 0 0 0 0] [:detach 0 0 0 0]]})))
|
|
|
|
(t/deftest ^:async switching-a-copy-of-a-swap-keeps-position-overrides-inherited
|
|
(await (replay {:world [2 1 {:library true :variants true}]
|
|
:ops [[:edit 0 0 1 2] [:update-main 0] [:library-sync]
|
|
[:undo] [:redo] [:reset 0] [:sync 1]
|
|
[:switch 13 0 0 0] [:rotate 0 0 0 0] [:switch 2 0 0 0]]})))
|
|
|
|
(t/deftest ^:async rotated-swapped-head-keeps-its-position-anchor-with-a-different-content-size
|
|
(await (replay {:world [2 2 {:variants true :variant-diff false}]
|
|
:ops [[:edit 0 0 1 1] [:switch 0] [:switch 0] [:swap 0]
|
|
[:undo] [:redo] [:reset 0] [:edit 0 1 1 1] [:update-main 0]
|
|
[:sync 1] [:swap 17 0 0 0] [:resize 0 0 0 0] [:rotate 0 0 0 0]]})))
|
|
|
|
(t/deftest ^:async pushing-a-swap-keeps-the-orientation-inherited-from-its-position
|
|
(await (replay {:world [2 1 {:library true :variants true}]
|
|
:ops [[:edit 0 0 1 2] [:update-main 0] [:library-sync]
|
|
[:undo] [:redo] [:reset 0] [:sync 1]
|
|
[:rotate 0 0 0 0] [:swap 13 0 0 0] [:update-main 1 0 0 0]]})))
|
|
|
|
(t/deftest ^:async resizing-a-copy-of-an-empty-flex-main-keeps-layout-valid
|
|
(await (replay {:world [3 0 {:text true :layout :flex}]
|
|
:ops [[:add-child 0] [:remove-child 0] [:duplicate 0] [:nest 0]
|
|
[:delete 0] [:restore 0] [:text 0 0 1] [:text 1 1 1]
|
|
[:resize 0 0 2] [:rotate 0 0 0] [:reset 0]
|
|
[:edit 0 0 1 1] [:update-main 0] [:sync 1]
|
|
[:detach 0] [:undo] [:redo] [:remove-child 0 0 0 0]
|
|
[:reset 0 0 0 0] [:nest 0 0 0 0] [:resize 0 0 0 0]]})))
|
|
|
|
(t/deftest ^:async updating-a-main-after-successive-rotations-keeps-child-flips
|
|
(await (replay {:world [2 1]
|
|
:ops [[:rotate 1 0 0 0] [:rotate 1 0 1 0] [:update-main 0 0 0 0]]})))
|
|
|
|
(t/deftest ^:async pushing-a-switched-child-uses-its-parents-pushed-frame
|
|
(await (replay {:world [2 1 {:library true :variants true}]
|
|
:ops [[:edit 0 0 1 2] [:update-main 0] [:library-sync]
|
|
[:undo] [:redo] [:reset 0] [:sync 1]
|
|
[:switch 5 0 0 0] [:rotate 1 0 0 0] [:update-main 0 0 0 0]]})))
|
|
|
|
(t/deftest ^:async minimum-size-parent-placement-keeps-fixed-child-dimensions
|
|
(await (replay {:world [2 0 {:text true :layout nil}]
|
|
:ops [[:add-child 0] [:remove-child 0] [:duplicate 0] [:nest 0]
|
|
[:delete 0] [:restore 0] [:text 0 0 1] [:text 1 1 1]
|
|
[:resize 0 0 2] [:rotate 0 0 0] [:reset 0]
|
|
[:edit 0 0 1 1] [:update-main 0] [:sync 1]
|
|
[:detach 0] [:undo] [:redo] [:resize 1 0 0 0]
|
|
[:nest 2 0 0 0] [:rotate 0 0 3 0] [:edit 0 0 0 0]]})))
|
|
|
|
(t/deftest ^:async generated-library-pushed-swap-authors-content-against-its-new-position
|
|
(await (replay {:world [2 1 {:library true :variants true}]
|
|
:ops [[:edit 0 0 1 2] [:update-main 0] [:library-sync]
|
|
[:undo] [:redo] [:reset 0] [:sync 1]
|
|
[:switch 2 0 0 0] [:edit 8 0 0 0] [:switch 0 0 0 0]
|
|
[:update-main 7 0 0 0]]})))
|
|
|
|
(t/deftest ^:async generated-library-swap-back-syncs-the-near-positions-overrides
|
|
(await (replay {:world [2 1 {:library true :variants true}]
|
|
:ops [[:edit 0 0 1 2] [:update-main 0] [:library-sync]
|
|
[:undo] [:redo] [:reset 0] [:sync 1]
|
|
[:switch 15 0 0 0] [:duplicate 16 0 0 0] [:edit 8 0 0 0]
|
|
[:switch 4 0 0 0] [:update-main 0 0 0 0]]})))
|
|
|
|
(t/deftest ^:async generated-library-move-restores-existing-component-nesting-on-undo
|
|
(await (replay {:world [2 1 {:library true :variants true}]
|
|
:ops [[:edit 0 0 1 2] [:update-main 0] [:library-sync]
|
|
[:undo] [:redo] [:reset 0] [:sync 1]
|
|
[:switch 5 0 0 0] [:nest 8 0 0 0] [:nest 5 0 0 0]
|
|
[:restore 0 0 0 0]]})))
|
|
|
|
(t/deftest ^:async generated-library-authored-child-follows-its-parents-synced-turn
|
|
(await (replay {:world [2 1 {:library true :variants true}]
|
|
:ops [[:edit 0 0 1 2] [:update-main 0] [:library-sync]
|
|
[:undo] [:redo] [:reset 0] [:sync 1]
|
|
[:resize 0 0 0 0] [:switch 2 0 0 0] [:rotate 1 0 0 0]
|
|
[:remove-child 0 0 0 0]]})))
|
|
|
|
(t/deftest ^:async applying-main-typography-drops-a-mixed-copys-link-without-an-override
|
|
(await (replay {:world [2 0 {:library true :variants true :rich-variants true
|
|
:text true :text-styles true :layout nil :layout-copies true}]
|
|
:ops [[:swap 0 0 0 0] [:text 23 3 1 0] [:text-style 22 8 1]
|
|
[:undo] [:undo] [:undo] [:redo] [:redo] [:redo]]})))
|
|
|
|
(t/deftest ^:async typography-ownership-stays-consistent-when-a-variant-changes-size
|
|
(await (replay {:world [2 0 {:library true :variants true :rich-variants true
|
|
:text true :text-styles true :layout nil :layout-copies true}]
|
|
:ops [[:text-style 4 8 1] [:switch 1 0 0 0]
|
|
[:undo] [:undo] [:redo] [:redo]]})))
|
|
|
|
(t/deftest ^:async detaching-after-a-nested-switch-keeps-placement-stable-through-sync
|
|
(await (replay {:world [2 2 {:library true :variants true :rich-variants true
|
|
:text true :text-styles true :layout :flex :layout-copies true}]
|
|
:ops [[:nest 7 0 0 0] [:switch 3 0 0 0] [:style 3 7 1] [:detach 6 0 0 0]
|
|
[:undo] [:undo] [:undo] [:undo] [:redo] [:redo] [:redo] [:redo]]})))
|
|
|
|
(t/deftest ^:async generated-library-switch-keeps-overrides-from-a-deleted-near-main
|
|
(await (replay {:world [2 1 {:library true :variants true}]
|
|
:ops [[:edit 0 0 1 2] [:update-main 0] [:library-sync]
|
|
[:undo] [:redo] [:reset 0] [:sync 1]
|
|
[:delete 0 0 0 0] [:delete 3 0 0 0] [:resize 0 0 0 0]
|
|
[:delete 9 0 0 0] [:switch 0 0 0 0]]})))
|
|
|
|
(t/deftest ^:async switching-an-untouched-rotated-copy-survives-full-sync
|
|
(await (replay {:world [3 2 {:variants true :variant-diff false}]
|
|
:ops [[:edit 0 0 1 1] [:switch 0] [:switch 0] [:swap 0] [:undo] [:redo]
|
|
[:reset 0] [:edit 0 1 1 1] [:update-main 0] [:sync 1]
|
|
[:edit 11 0 0 0] [:rotate 2 0 0 0] [:nest 3 0 0 0] [:resize 3 0 0 0]
|
|
[:nest 3 0 0 0] [:swap 10 0 0 0] [:resize 3 0 0 0]
|
|
[:update-main 5 0 0 0] [:switch 0 0 0 0] [:detach 0 0 0 0]]})))
|
|
|
|
(t/deftest ^:async switch-keeps-retained-orientation-together-with-carried-size
|
|
(await (replay {:world [2 2 {:variants true :variant-diff false}]
|
|
:ops [[:edit 0 0 1 1] [:switch 0] [:switch 0] [:swap 0] [:undo] [:redo]
|
|
[:reset 0] [:edit 0 1 1 1] [:update-main 0] [:sync 1]
|
|
[:swap 0 0 0 0] [:delete 0 0 0 0] [:rotate 0 0 0 0]
|
|
[:nest 0 0 0 0] [:detach 0 0 0 0] [:update-main 0 0 0 0]
|
|
[:switch 0 0 0 0]]})))
|
|
|
|
(t/deftest ^:async generated-library-duplicate-refuses-an-expanding-component-branch
|
|
(await (replay {:world [2 1 {:library true :variants true}]
|
|
:ops [[:edit 0 0 1 2] [:update-main 0] [:library-sync]
|
|
[:undo] [:redo] [:reset 0] [:sync 1]
|
|
[:switch 5] [:nest 8] [:duplicate 1]]})))
|
|
|
|
(t/deftest ^:async generated-library-parent-turn-settles-swapped-placement
|
|
(await (replay {:world [2 1 {:library true :variants true}]
|
|
:ops [[:edit 0 0 1 2] [:update-main 0] [:library-sync]
|
|
[:undo] [:redo] [:reset 0] [:sync 1]
|
|
[:switch 2 0 0 0] [:resize 0 0 0 0] [:rotate 2 0 0 0]]})))
|
|
|
|
(t/deftest ^:async generated-library-restored-variant-syncs-its-converted-name
|
|
(await (replay {:world [2 1 {:library true :variants true}]
|
|
:ops [[:edit 0 0 1 2] [:update-main 0] [:library-sync]
|
|
[:undo] [:redo] [:reset 0] [:sync 1]
|
|
[:delete 3 0 0 0] [:delete 1 0 0 0] [:restore 7 0 0 0]
|
|
[:delete 1 0 0 0] [:restore 0 0 0 0]]})))
|
|
|
|
(t/deftest ^:async generated-library-switch-inherits-a-swapped-near-mains-authored-fill
|
|
(await (replay {:world [2 1 {:library true :variants true}]
|
|
:ops [[:edit 0 0 1 2] [:update-main 0] [:library-sync]
|
|
[:undo] [:redo] [:reset 0] [:sync 1]
|
|
[:edit 12 0 0 0] [:nest 10 0 0 0]
|
|
[:switch 7 0 0 0] [:switch 2 0 0 0]]})))
|
|
|
|
(t/deftest ^:async generated-library-reset-places-new-children-after-clearing-rotation
|
|
(await (replay {:world [2 1 {:library true :variants true}]
|
|
:ops [[:edit 0 0 1 2] [:update-main 0] [:library-sync]
|
|
[:undo] [:redo] [:reset 0] [:sync 1]
|
|
[:switch 1 0 0 0] [:rotate 1 0 0 0] [:duplicate 0 0 0 0]
|
|
[:reset 2 0 0 0] [:redo 0 0 0 0]]})))
|
|
|
|
(t/deftest ^:async generated-update-main-settles-a-turned-swapped-position
|
|
(await (replay {:world [2 2 {:variants true :variant-diff false}]
|
|
:ops [[:edit 0 0 1 1] [:switch 0] [:switch 0] [:swap 0] [:undo] [:redo]
|
|
[:reset 0] [:edit 0 1 1 1] [:update-main 0] [:sync 1]
|
|
[:delete 8 0 0 0] [:swap 15 0 0 0] [:edit 14 0 0 0]
|
|
[:resize 4 0 0 0] [:resize 0 0 0 0] [:nest 4 0 0 0]
|
|
[:rotate 5 0 0 0] [:update-main 14 0 0 0] [:duplicate 0 0 0 0]]})))
|
|
|
|
(t/deftest ^:async generated-an-unmask-in-a-flex-main-places-the-group-again
|
|
;; an unmasked group takes the bounds of all its children, which the flex
|
|
;; it is in places again
|
|
(await (replay {:world [2 0 {:variants false :rich-variants false :text true :layout :flex
|
|
:layout-copies false :layout-children true}]
|
|
:ops [[:structure 11 1 13] [:structure 0 3]]})))
|
|
|
|
(t/deftest ^:async generated-a-bool-in-a-grid-is-placed-by-it
|
|
;; a bool takes the bounds of its result, which the grid it is in places
|
|
(await (replay {:world [3 0 {:variants true :rich-variants true :text true :layout :grid
|
|
:layout-copies true :layout-children true}]
|
|
:ops [[:rotate 16 0 7 0] [:grid-direction 0 0 0 1] [:grid-cell 0 10 0 1] [:add-child 0]
|
|
[:structure 3 6 15] [:grid-direction 0 0 0 1] [:grid-cell 0 4 2 1]]})))
|
|
|
|
(t/deftest ^:async generated-a-turned-variant-set-to-fill-in-a-hugging-board-keeps-its-turn
|
|
;; the sidebar fixes the hugging variant board before the turned variant
|
|
;; fills it, as the model does
|
|
(await (replay {:world [3 2 {:variants true :text-styles true :layout nil :variant-diff false
|
|
:layout-item-margins false :grid-square false :rich-variants true
|
|
:layout-children false :grid-empty false :layout-copies true :text true}]
|
|
:ops [[:rotate 7 0 0 0] [:update-main 0 0 0 0] [:make-variant 19 0 0 0] [:style 0 29 4 0]]})))
|
|
|
|
(t/deftest ^:async generated-a-turned-fill-swap-settles-like-its-main-after-the-layout
|
|
;; the layout of a row fills a swapped head turned with its main, which
|
|
;; then settles its placement as the main's
|
|
(await (replay {:world [2 2 {:variants true :layout :flex :rich-variants true :layout-copies true :text true}]
|
|
:ops [[:delete 0] [:restore 0] [:add-variant 0 0 0 0] [:swap 6 0 0 0] [:combine 5 0 0 0]
|
|
[:delete 12 0 0 0] [:combine 9 0 0 0] [:nest 0 0 0 0] [:restore 0 0 0 0] [:combine 8]
|
|
[:switch 3] [:style 0 30 1] [:detach 1 0 0 0] [:combine 0] [:switch 7] [:nest 4 0 0 0]
|
|
[:rotate 2 0 0 0]]})))
|
|
|
|
(t/deftest ^:async generated-an-ungroup-in-a-grid-main-undoes-in-one-step
|
|
;; the copies' repositioning, synced from the layout update after the
|
|
;; ungroup, undoes with the ungroup
|
|
(await (replay {:world [2 2 {:variants true :text true :layout :grid :layout-copies true}]
|
|
:ops [[:detach 6 0 0 0] [:structure 0 2 0]]})))
|
|
|
|
(t/deftest ^:async generated-an-update-main-of-a-grid-direction-orders-the-main-by-it
|
|
;; the main takes the copy's column direction and its layout reflows,
|
|
;; ordering its children by their cells in that direction
|
|
(await (replay {:world [3 2 {:variants true :layout :grid :grid-square true :layout-children true :text true}]
|
|
:ops [[:make-variant] [:make-variant 6] [:combine] [:make-variant 11] [:combine]
|
|
[:remove-child 9] [:grid-direction 0 0 13] [:update-main]]})))
|
|
|
|
(t/deftest ^:async generated-a-detach-under-an-unaccepted-child-removal-leaves-it-plain
|
|
;; the loaded library no longer has the nested copy's child main, so the
|
|
;; detach leaves that child plain until the consumer accepts the library
|
|
(await (replay {:world [2 0 {:variants true :stale-libraries true :library true :rich-variants true}]
|
|
:ops [[:library-delete 0 0 0 0] [:library-restore 0 0 0 0] [:library-remove-child 3 0 0 0]
|
|
[:detach 11 0 0 0] [:library-undo] [:library-redo]]})))
|
|
|
|
(t/deftest ^:async generated-a-duplicate-of-a-copy-back-on-its-older-library-keeps-it
|
|
;; after an undone library sync, a duplicate of a copy holds the values of
|
|
;; the library version the copy is back on
|
|
(await (replay {:world [2 0 {:variants true :library-variants true :stale-libraries true :library true}]
|
|
:ops [[:library-edit 2 0 0] [:library-sync] [:undo 0 0 0 0] [:duplicate 15 0 0 0]]})))
|
|
|
|
(t/deftest ^:async generated-a-library-sync-keeps-another-librarys-pending-turn-out
|
|
;; a sync from one library takes it as loaded and keeps the version of the
|
|
;; other library the consumer had accepted
|
|
(await (replay {:world [2 1 {:library true :stale-libraries true :library-dependency true :library-text true}]
|
|
:ops [[:swap 4 0 0 0] [:swap 9 0 0 0] [:library-transform 5 3 4 0] [:library-sync 0 0 0 0]]})))
|
|
|
|
(t/deftest ^:async generated-a-token-value-edit-and-its-propagation-undo-together
|
|
;; the token form commits the edit and its propagation as one undo step
|
|
(await (replay {:world [1 0 {:tokens true :variants true :rich-variants false :text false
|
|
:layout :flex :layout-copies false}]
|
|
:ops [[:transform 0 10 0 8] [:apply-token 12 11] [:style 12 3 0 1] [:token-value 0 2]]})))
|
|
|
|
(t/deftest ^:async programs-of-a-file-replay-through-the-frontend
|
|
;; the programs of the EDN file `PENPOT_REPLAY_PROGRAMS` names, when it
|
|
;; names one, each replayed and reported on its own
|
|
(when-let [path (unchecked-get (.-env js/process) "PENPOT_REPLAY_PROGRAMS")]
|
|
(let [programs (try
|
|
(reader/read-string (str (.readFileSync (.getBuiltinModule js/process "fs") path)))
|
|
(catch :default cause
|
|
(js/console.log "REPLAY-FILE unreadable" (ex-message cause))
|
|
[]))]
|
|
(loop [index 0]
|
|
(when (< index (count programs))
|
|
(let [before (:report-counters (t/get-current-env))]
|
|
(await (replay (nth programs index)))
|
|
(let [after (:report-counters (t/get-current-env))]
|
|
(js/console.log "REPLAY-FILE" index
|
|
(pr-str (merge-with - (select-keys after [:pass :fail :error])
|
|
(select-keys before [:pass :fail :error]))))))
|
|
(recur (inc index)))))))
|