penpot/frontend/test/frontend_tests/data/workspace_undo_test.cljs
alonso.torres 3e6c98c01a ✨ Generate and check random component histories
The Phase 4 bug hunt: random component programs, an independent model
of what they should leave, and the regression programs of what they
found. The production fixes they found are the commits before this one,
each with its regression programs; this commit holds the test harness,
the rest of the tests and the memories they grew with. A regression
program that needs the harness runs once this commit is in.

- Generation (composable gen): worlds of components, nested copies,
  variants, libraries (stale and dependent), flex and grid layouts and
  texts; operations for structure, geometry, styles, texts, layout items,
  grid tracks and cells, swaps, variant switches, update main, reset,
  detach, library edits and syncs, undo and redo; shrinking, coverage
  accounting per operation kind, and PENPOT_GEN_SEED, PENPOT_GEN_NUM
  and PENPOT_GEN_HISTORIES to choose the seed, the number of programs
  and their length.
- The oracle: invariants on touched groups, overrides, refs, settled
  versus full sync, design snapshots and the model values, with its
  own model of authored intent (shadow, geometry, grid and variant
  rules) instead of production's results.
- The frontend replays generated programs through the workspace events
  and the completion contract, with undo and redo checks.
- The oracle unit tests, the test runners' registrations, the golden
  masters recorded again where a fix changed them, and the memories of
  the component sync contract and its tests.

Harness only; the benchmark is not run.

Also in this commit:

- Adapt develop's variant set and reload tests to this branch. Develop's tests
  of transforming a component into a variant set call the event with the set's
  id and expect the defining commit to hold only the main. Here the transform
  builds the whole set, its second member included, in one commit:
  transform-in-variant takes an optional variant id, and the tests expect both
  members in that commit.
- Restore the requires and test wiring the rebase merges dropped.
- Generate variant property edits and added variants. The random programs
  switched between the members of a variant set but never changed the set.

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

280 lines
13 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.data.workspace-undo-test
"Tests for the undo groups of commits and history entries, and for
forgetting them after a rollback."
(:require
[app.common.test-helpers.files :as cthf]
[app.common.test-helpers.ids-map :as cthi]
[app.common.uuid :as uuid]
[app.main.data.changes :as dch]
[app.main.data.comments :as dcmt]
[app.main.data.fonts :as df]
[app.main.data.workspace :as dw]
[app.main.data.workspace.undo :as dwu]
[beicon.v2.core :as rx]
[cljs.test :as t :include-macros true]
[frontend-tests.helpers.async :as async]
[frontend-tests.helpers.mock :as mock]
[frontend-tests.helpers.state :as ths]
[potok.v2.core :as ptk]))
(t/use-fixtures :each {:before cthi/reset-idmap!})
(defn- rename-page
"Commits a page rename, with `params` for `commit-changes`."
[page-id name & {:as params}]
(dch/commit-changes (merge {:redo-changes [{:type :mod-page :id page-id :name name}]
:undo-changes [{:type :mod-page :id page-id :name "Page 1"}]}
params)))
(defn- run-commits
"Runs `events` on a store of a sample file and calls `check` with the
undo groups of the commits made and the final state."
[done events check]
(let [file (cthf/sample-file :file1 :page-label :page1)
store (ths/setup-store file)
groups (atom [])
sub (->> (ptk/input-stream store)
(rx/filter dch/commit?)
(rx/subs! #(swap! groups conj (:undo-group (deref %)))))]
(ths/run-store store done (events (cthf/current-page-id file))
(fn [state]
(rx/dispose! sub)
(check @groups state)))))
;; Scenario: an action commits twice inside one undo transaction (as applying
;; a token to several shapes does). Proves: both commits carry the undo group
;; of the transaction, which its history entry takes too, so a rejected save
;; reverts the whole Ctrl+Z step, not half of it.
(t/deftest commits-inside-a-transaction-share-its-undo-group
(t/async
done
(let [tx (js/Symbol)
tx-group (atom nil)
spy (ptk/reify ::spy-transaction
ptk/EffectEvent
(effect [_ state _]
(reset! tx-group (get-in state [:workspace-undo :transaction :commit-group]))))]
(run-commits done
(fn [page-id]
[(dwu/start-undo-transaction tx)
spy
(rename-page page-id "A")
(rename-page page-id "B")
(dwu/commit-undo-transaction tx)])
(fn [groups _]
(t/is (some? @tx-group) "the transaction has its own group")
(t/is (= [@tx-group @tx-group] groups)))))))
;; Scenario: commits made with no transaction open. Proves: each one keeps
;; its own undo group.
(t/deftest commits-outside-a-transaction-get-their-own-undo-group
(t/async
done
(run-commits done
(fn [page-id]
[(rename-page page-id "A")
(rename-page page-id "B")])
(fn [groups _]
(t/is (= 2 (count (distinct groups))))))))
;; Scenario: inside a transaction, a commit names its undo group (e.g. a
;; component update that also writes the library). Proves: the explicit group
;; is kept.
(t/deftest an-explicit-undo-group-is-kept-inside-a-transaction
(t/async
done
(let [tx (js/Symbol)
group (uuid/next)]
(run-commits done
(fn [page-id]
[(dwu/start-undo-transaction tx)
(rename-page page-id "A" :undo-group group)
(dwu/commit-undo-transaction tx)])
(fn [groups _]
(t/is (= [group] groups)))))))
;; Scenario: a rollback forgets undo groups while a transaction is open, then
;; the transaction commits again. Proves: the later commit keeps the group of
;; the earlier one, so the transaction stays one rollback unit.
(t/deftest a-transaction-keeps-its-undo-group-after-forget-undo-groups
(t/async
done
(let [tx (js/Symbol)]
(run-commits done
(fn [page-id]
[(dwu/start-undo-transaction tx)
(rename-page page-id "A")
(ptk/reify ::forget-the-transaction-group
ptk/UpdateEvent
(update [_ state]
(let [group (get-in state [:workspace-undo :transaction :commit-group])]
;; The transaction holds the first commit, as `append-undo` records it
(->> (assoc-in state [:workspace-undo :transaction :undo-groups] #{group})
(ptk/update (dwu/forget-undo-groups #{group} nil))))))
(rename-page page-id "B")
(dwu/commit-undo-transaction tx)])
(fn [[first-group second-group :as groups] _]
(t/is (= 2 (count groups)))
(t/is (some? first-group))
(t/is (= first-group second-group)))))))
(defn- entry
[page-id name group]
{:undo-changes [{:type :mod-page :id page-id :name "Page 1"}]
:redo-changes [{:type :mod-page :id page-id :name name}]
:undo-group group
:tags #{}
:translation false})
;; Scenario: inside one transaction, a commit names another undo group (as a
;; component update does). Proves: the history entry records both groups,
;; so a rollback of either one finds it.
(t/deftest a-transaction-entry-records-every-group-it-holds
(let [page-id (uuid/next)
[g1 g2] (repeatedly 2 uuid/next)
tx (js/Symbol)
state (reduce #(ptk/update %2 %1)
{}
[(dwu/start-undo-transaction tx)
(dwu/append-undo (entry page-id "A" g1) false)
(dwu/append-undo (entry page-id "B" g2) false)
(dwu/commit-undo-transaction tx)])]
(t/is (= #{g1 g2} (get-in state [:workspace-undo :items 0 :undo-groups])))))
;; Scenario: a commit stacks onto the last history entry. Proves: the entry
;; records the stacked commit's group too.
(t/deftest a-stacked-commit-adds-its-group-to-the-entry
(let [page-id (uuid/next)
[g1 g2] (repeatedly 2 uuid/next)
state (reduce #(ptk/update %2 %1)
{}
[(dwu/append-undo (entry page-id "A" g1) false)
(dwu/append-undo (entry page-id "B" g2) true)])]
(t/is (= 1 (count (get-in state [:workspace-undo :items]))))
(t/is (= #{g1 g2} (get-in state [:workspace-undo :items 0 :undo-groups])))))
;; Scenario: the user presses Ctrl+Z on a page rename. Proves: the commit it
;; makes can be undone (its undo changes redo the rename) and names the index
;; the history moved from, so a rollback can put both back.
(t/deftest an-undo-commit-can-be-undone
(t/async
done
(let [file (cthf/sample-file :file1 :page-label :page1)
page-id (cthf/current-page-id file)
store (ths/setup-store file)
commits (atom [])
sub (->> (ptk/input-stream store)
(rx/filter dch/commit?)
(rx/subs! #(swap! commits conj (deref %))))
item (assoc (entry page-id "A" (uuid/next)) :undo-groups #{})]
(ths/run-store store done
[#(assoc % :workspace-undo {:items [item] :index 0})
dwu/undo]
(fn [state]
(rx/dispose! sub)
(let [[commit] @commits]
(t/is (= 1 (count @commits)))
(t/is (= (:undo-changes item) (:redo-changes commit)))
(t/is (= (:redo-changes item) (:undo-changes commit)))
(t/is (= 0 (:undo-index commit)))
(t/is (= -1 (get-in state [:workspace-undo :index])))))))))
;; Forgetting the undo groups of a rollback.
(defn- entry-of-groups
"An undo entry holding commits of `groups`, the first one naming it."
[& groups]
{:undo-group (first groups) :undo-groups (set groups)})
(defn- forget
"The undo state after forgetting `groups` from `undo-state`."
[undo-state groups undo-index]
(:workspace-undo (ptk/update (dwu/forget-undo-groups groups undo-index)
{:workspace-undo undo-state})))
(t/deftest forgetting-undo-groups-cuts-the-history-at-the-first-match
(let [[g1 g2 g3] (repeatedly 3 uuid/next)
undo (forget {:items [(entry-of-groups g1) (entry-of-groups g2) (entry-of-groups g3)]
:index 2
:transaction {:undo-group g3 :undo-changes [{:type :mod-page}]}}
#{g2 g3} nil)]
(t/is (= [g1] (mapv :undo-group (:items undo))))
(t/is (= 0 (:index undo)))
(t/is (empty? (get-in undo [:transaction :undo-changes])) "the open transaction is emptied")
(t/is (= g3 (get-in undo [:transaction :commit-group]))
"its later commits keep the group of its earlier ones")))
(t/deftest forgetting-undo-groups-matches-any-group-an-entry-holds
(let [[g1 g2 g3] (repeatedly 3 uuid/next)
undo (forget {:items [(entry-of-groups g1) (entry-of-groups g2 g3)] :index 1}
#{g3} nil)]
(t/is (= [g1] (mapv :undo-group (:items undo))))
(t/is (= 0 (:index undo)))))
(t/deftest forgetting-undo-groups-keeps-the-history-without-a-match
(let [[g1 g2] (repeatedly 2 uuid/next)
tx {:undo-group g2 :undo-groups #{g2} :undo-changes [{:type :mod-page}]}
undo (forget {:items [(entry-of-groups g1)] :index 0 :transaction tx}
#{(uuid/next)} nil)]
(t/is (= [g1] (mapv :undo-group (:items undo))))
(t/is (= 0 (:index undo)))
(t/is (= tx (:transaction undo)) "an unrelated open transaction stays")))
(t/deftest forgetting-undo-groups-empties-a-transaction-that-holds-one
(let [[g1 g2] (repeatedly 2 uuid/next)
tx {:undo-group g2 :undo-groups #{g2} :undo-changes [{:type :mod-page}]}
undo (forget {:items [(entry-of-groups g1)] :index 0 :transaction tx}
#{g2} nil)]
(t/is (= [g1] (mapv :undo-group (:items undo))) "the history stays")
(t/is (empty? (get-in undo [:transaction :undo-changes])))
(t/is (= g2 (get-in undo [:transaction :commit-group])))))
(t/deftest forgetting-undo-groups-points-back-to-the-index-of-an-undone-undo
(let [[g1 g2 g3] (repeatedly 3 uuid/next)
undo-state {:items [(entry-of-groups g1) (entry-of-groups g2) (entry-of-groups g3)]
:index 0}]
(t/is (= 2 (:index (forget undo-state #{(uuid/next)} 2))))
(t/is (= 0 (:index (forget undo-state #{g2} 2)))
"a cut history cannot point past its end")))
;; Scenario: the workspace opens and then reloads twice (a peer's restore,
;; the rollback fallback), each reload running `initialize-workspace` again
;; without leaving the workspace, and each loaded file starting the edit
;; watchers that record undo entries (the file load is mocked, so the test
;; starts them); then one commit is made. Proves: each reload replaces the
;; workspace streams, so the commit adds one undo entry, not one per reload.
(t/deftest ^:async a-workspace-reload-adds-one-undo-entry-per-commit
(let [file (cthf/sample-file :file1 :page-label :page1)
team-id (uuid/next)
store (ths/setup-store file {:renderer :svg})
loaded (fn [type] (mock/stub (fn [& _] (ptk/data-event type {}))))]
(await
(mock/with-mocks*
{dw/initialize-file (loaded ::file-requested)
dcmt/retrieve-comment-threads (loaded ::threads-requested)
dcmt/fetch-profiles (loaded ::profiles-requested)
df/fetch-fonts (loaded ::fonts-requested)}
(try
(ptk/emit! store
#(assoc % :current-team-id team-id)
(dw/initialize-workspace team-id (:id file))
(dw/initialize-edit-watchers)
(ptk/event ::dw/reload-current-file)
(dw/initialize-edit-watchers)
(ptk/event ::dw/reload-current-file)
(dw/initialize-edit-watchers))
(await (async/settle))
(ptk/emit! store (rename-page (cthf/current-page-id file) "Renamed"))
(await (async/wait-for #(seq (get-in @store [:workspace-undo :items]))
"the commit reaches the undo history"))
(await (async/settle))
(t/is (= 1 (count (get-in @store [:workspace-undo :items]))))
(finally
(rx/dispose! store)))))))