mirror of
https://github.com/penpot/penpot.git
synced 2026-11-22 18:30:34 +00:00
A copy text that sets its own family and weight keeps the variant id its family names for that weight. When the main later shows the same weight, the weight is equal on both sides and sync does not place it, so the family's variant ids were not given either: the copy's Roboto run took the main's "bold", a variant of another family. The family's side now gives its variants whenever the family is placed and the weight is not. Benchmark (scripts/bench-components, ms, lower 2.5% quantile): | world | baseline | now | ratio | |------------------------------------+----------+---------+-------| | deepest-edit-through-three-levels | 35.215 | 20.095 | 0.57 | | edit-through-a-chain-of-dependents | 68.931 | 39.445 | 0.57 | | library-update-into-copies | 83.083 | 45.617 | 0.55 | | main-edit-among-many-shapes | 4.837 | 2.227 | 0.46 | | main-edit-into-10-copies | 1.79 | 0.961 | 0.54 | | main-edit-into-100-copies | 15.415 | 9.374 | 0.61 | | main-edit-into-1000-copies | 153.086 | 94.792 | 0.62 | | variant-switch-into-copies | 32.052 | 20.436 | 0.64 | AI-assisted-by: claude-opus-5-5
423 lines
21 KiB
Clojure
423 lines
21 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 common-tests.logic.text-override-sync-test
|
|
"What a copy text holds after its main changes and syncs, when the copy
|
|
has its own letters or styles (`mem:common/component-sync-contract`):
|
|
- letters and line breaks are one override, and each style another;
|
|
- a copy's style override covers the whole text;
|
|
- the main's styles go onto letters that differ from its own by three
|
|
rules: a style with one value across the main's text applies to every
|
|
letter; otherwise letters both texts share (a stretch of at least 3)
|
|
take the main's style; any other letter takes the style of the letter
|
|
before it, or at the start of the text, of the first shared letter
|
|
after it, or with nothing shared, of the main's first letter.
|
|
Texts are written in the notation of `app.common.test-helpers.texts`."
|
|
(:require
|
|
[app.common.files.changes-builder :as pcb]
|
|
[app.common.logic.libraries :as cll]
|
|
[app.common.logic.shapes :as cls]
|
|
[app.common.test-helpers.components :as thc]
|
|
[app.common.test-helpers.compositions :as tho]
|
|
[app.common.test-helpers.files :as thf]
|
|
[app.common.test-helpers.ids-map :as thi]
|
|
[app.common.test-helpers.shapes :as ths]
|
|
[app.common.test-helpers.texts :as thtx]
|
|
[app.common.types.text :as txt]
|
|
[app.common.types.typographies-list :as cttl]
|
|
[clojure.test :as t]))
|
|
|
|
(t/use-fixtures :each thi/test-fixture)
|
|
|
|
(def ^:private heading
|
|
{:family "Inter" :weight 700 :size 24 :spacing 1 :case "uppercase" :line-height 1.4})
|
|
|
|
(def ^:private body
|
|
{:family "Roboto" :weight 300 :size 16 :spacing 0.5 :case "capitalize" :line-height 1.6})
|
|
|
|
(defn- sample-file
|
|
"A file with the typographies :heading and :body."
|
|
[]
|
|
(-> (thf/sample-file :file1)
|
|
(ths/add-sample-typography :heading)
|
|
(ths/add-sample-typography :body)))
|
|
|
|
(defn- sync-text
|
|
"The copy's text when the main starts as `main`, the copy writes
|
|
`copy-text` (nil for no edit), then the main writes `main-text` and syncs."
|
|
[main copy-text main-text]
|
|
(-> (sample-file)
|
|
(thtx/add-text-component-with-copy main)
|
|
(cond-> (some? copy-text) (thtx/set-text :copy-child copy-text))
|
|
(thtx/set-text :main-child main-text)
|
|
(tho/propagate-component-changes :component1)
|
|
(thtx/text-of :copy-child)))
|
|
|
|
;; ---- Whole-text edits: every copy edit against every main edit
|
|
|
|
(def ^:private base [[["Hello world"]]])
|
|
|
|
(def ^:private copy-edits
|
|
{:letters #(thtx/set-letters % "Buy now")
|
|
:new-paragraph #(thtx/set-letters % "Hello world\nEnds Sunday")
|
|
:color #(thtx/restyle % :color :red)
|
|
:family #(thtx/restyle % :family "Roboto")
|
|
:size #(thtx/restyle % :size 18)
|
|
:weight #(thtx/restyle % :weight 700)
|
|
:spacing #(thtx/restyle % :spacing 2)
|
|
:decoration #(thtx/restyle % :decoration "underline")
|
|
:case #(thtx/restyle % :case "uppercase")
|
|
:line-height #(thtx/restyle-paragraphs % :line-height 1.5)
|
|
:align #(thtx/restyle-paragraphs % :align "center")
|
|
:direction #(thtx/restyle-paragraphs % :direction "rtl")
|
|
:valign #(thtx/set-valign % "bottom")
|
|
:letters-and-color #(-> % (thtx/set-letters "Buy now") (thtx/restyle :color :red))
|
|
:typography #(thtx/apply-typography % :heading heading)})
|
|
|
|
(def ^:private main-edits
|
|
{:letters #(thtx/set-letters % "Add to bag")
|
|
:new-paragraph #(thtx/set-letters % "Hello world\nSecond line")
|
|
:color #(thtx/restyle % :color :blue)
|
|
:family #(thtx/restyle % :family "Inter")
|
|
:size #(thtx/restyle % :size 24)
|
|
:weight #(thtx/restyle % :weight 300)
|
|
:spacing #(thtx/restyle % :spacing 1)
|
|
:decoration #(thtx/restyle % :decoration "line-through")
|
|
:case #(thtx/restyle % :case "lowercase")
|
|
:line-height #(thtx/restyle-paragraphs % :line-height 2)
|
|
:align #(thtx/restyle-paragraphs % :align "right")
|
|
:direction #(thtx/restyle-paragraphs % :direction "rtl")
|
|
:valign #(thtx/set-valign % "center")
|
|
:typography #(thtx/apply-typography % :body body)})
|
|
|
|
(defn- weight-variant
|
|
"`expected` with the variant id of `weight-side`'s first run, when the
|
|
family comes from the other side: sync keeps the variant id with the
|
|
weight, and the frontend then picks the family's closest variant."
|
|
[expected weight-side]
|
|
(thtx/restyle expected :font-variant-id
|
|
(get-in (thtx/content weight-side) [:children 0 :children 0 :children 0 :font-variant-id])))
|
|
|
|
(t/deftest whole-text-copy-edits-against-main-edits
|
|
;; Whole-text edits commute with the rules: the copy keeps what it
|
|
;; edited and takes the rest from the main, which is its edit applied
|
|
;; over the main's new text.
|
|
(doseq [[copy-title copy-edit] copy-edits
|
|
[main-title main-edit] main-edits]
|
|
(t/testing (str "copy " copy-title ", main " main-title)
|
|
(let [actual (sync-text base (copy-edit base) (main-edit base))
|
|
expected (cond-> (copy-edit (main-edit base))
|
|
(and (= copy-title :weight) (#{:family :typography} main-title))
|
|
(weight-variant (copy-edit base)))]
|
|
(t/is (= (thtx/normalize expected) actual))))))
|
|
|
|
;; ---- One style no longer blocks the others
|
|
|
|
(t/deftest recolored-copy-takes-the-main-font-and-size
|
|
(let [main [[["Add to cart" {:weight 600}]]]
|
|
copy [[["Add to cart" {:weight 600 :color :red}]]]
|
|
main' [[["Add to cart" {:weight 600 :family "Roboto" :size 18}]]]
|
|
actual (sync-text main copy main')]
|
|
(t/is (= [[["Add to cart" {:family "Roboto" :weight 600 :size 18 :color :red}]]] actual))))
|
|
|
|
(t/deftest relabeled-and-recolored-copy-takes-the-main-size
|
|
(let [main [[["Add to cart" {:weight 600}]]]
|
|
copy [[["Buy now" {:weight 600 :color :red}]]]
|
|
main' [[["Add to cart" {:weight 600 :size 18}]]]
|
|
actual (sync-text main copy main')]
|
|
(t/is (= [[["Buy now" {:weight 600 :size 18 :color :red}]]] actual))))
|
|
|
|
(t/deftest centered-copy-stays-centered
|
|
(let [main [[["Free shipping"]]]
|
|
copy [[{:align "center"} ["Free shipping"]]]
|
|
main' [[["Free shipping" {:size 18}]]]
|
|
actual (sync-text main copy main')]
|
|
(t/is (= [[{:align "center"} ["Free shipping" {:size 18}]]] actual))))
|
|
|
|
(t/deftest copy-with-a-font-size-token-takes-the-main-color
|
|
(let [main [[["Add to cart" {:weight 600}]]]
|
|
file (-> (sample-file)
|
|
(thtx/add-text-component-with-copy main))
|
|
page (thf/current-page file)
|
|
;; applying a token writes its value into the content and records it
|
|
file (thf/apply-changes
|
|
file
|
|
(cls/generate-update-shapes (pcb/empty-changes nil (:id page))
|
|
#{(thi/id :copy-child)}
|
|
#(assoc %
|
|
:content (thtx/content [[["Add to cart" {:weight 600 :size 16}]]])
|
|
:applied-tokens {:font-size "size.md"})
|
|
(:objects page)
|
|
{}))
|
|
file' (-> file
|
|
(thtx/set-text :main-child [[["Add to cart" {:weight 600 :color :blue}]]])
|
|
(tho/propagate-component-changes :component1))]
|
|
(t/is (= [[["Add to cart" {:weight 600 :size 16 :color :blue}]]]
|
|
(thtx/text-of file' :copy-child)))))
|
|
|
|
;; ---- Bolding a word
|
|
|
|
(def ^:private hello-bold [[["Hello" {:weight 700}] [" world"]]])
|
|
|
|
(t/deftest copy-that-bolds-a-word-takes-the-main-color
|
|
(t/is (= [[["Hello" {:weight 700 :color :blue}] [" world" {:color :blue}]]]
|
|
(sync-text [[["Hello world"]]] hello-bold [[["Hello world" {:color :blue}]]]))))
|
|
|
|
(t/deftest copy-that-bolds-a-word-takes-the-main-letters
|
|
;; "Hello" is shared, so it stays bold; " there" follows the space
|
|
(t/is (= [[["Hello" {:weight 700}] [" there"]]]
|
|
(sync-text [[["Hello world"]]] hello-bold [[["Hello there"]]]))))
|
|
|
|
(t/deftest copy-that-bolds-a-word-takes-the-main-family
|
|
;; the bold keeps its variant id, for the frontend to pick Roboto's bold
|
|
(t/is (= [[["Hello" {:family "Roboto" :weight 700 :font-variant-id "bold"}] [" world" {:family "Roboto"}]]]
|
|
(sync-text [[["Hello world"]]] hello-bold [[["Hello world" {:family "Roboto"}]]]))))
|
|
|
|
(t/deftest copy-with-its-own-family-keeps-its-familys-variant-of-the-main-weight
|
|
;; the copy's Roboto names its bold "700", the main's family "bold"
|
|
(t/is (= [[["Hello world" {:family "Roboto" :weight 700 :color :blue}]]]
|
|
(sync-text [[["Hello world" {:weight 700}]]]
|
|
[[["Hello world" {:family "Roboto" :weight 700}]]]
|
|
[[["Hello world" {:weight 700 :color :blue}]]]))))
|
|
|
|
(t/deftest copy-with-its-own-family-and-weight-keeps-its-familys-variant
|
|
;; the copy's Roboto names its bold "700"; the main turning bold as well
|
|
;; leaves the weight equal on both sides, and the main's "bold" stays its own
|
|
(t/is (= [[["Hello world" {:family "Roboto" :weight 700 :color :blue}]]]
|
|
(sync-text [[["Hello world"]]]
|
|
[[["Hello world" {:family "Roboto" :weight 700}]]]
|
|
[[["Hello world" {:weight 700 :color :blue}]]]))))
|
|
|
|
(t/deftest copy-that-bolds-a-word-the-main-replaces-loses-the-bold
|
|
;; "Goodbye" shares no stretch of 3 letters with "Hello", so it takes the
|
|
;; style of the first shared letter after it, the regular space
|
|
(t/is (= [[["Goodbye world"]]]
|
|
(sync-text [[["Hello world"]]] hello-bold [[["Goodbye world"]]]))))
|
|
|
|
(t/deftest copy-that-bolds-a-word-the-main-changes-by-one-letter
|
|
;; "llo world" is shared; "Ha" at the start takes the bold "l" after it
|
|
(t/is (= [[["Hallo" {:weight 700}] [" world"]]]
|
|
(sync-text [[["Hello world"]]] hello-bold [[["Hallo world"]]]))))
|
|
|
|
(t/deftest copy-that-bolds-a-letter-of-a-short-label
|
|
;; a lone shared letter carries nothing: with no stretch of 3 shared, all
|
|
;; letters take the style of the copy's first letter
|
|
(let [copy [[["O"] ["K" {:weight 700}]]]]
|
|
(t/is (= [[["Ok"]]] (sync-text [[["OK"]]] copy [[["Ok"]]])))))
|
|
|
|
(t/deftest copy-that-bolds-a-word-keeps-its-weights-when-the-main-is-light
|
|
;; an override covers the whole text, so "world" stays regular
|
|
(t/is (= hello-bold
|
|
(sync-text [[["Hello world"]]] hello-bold [[["Hello world" {:weight 300}]]]))))
|
|
|
|
;; ---- Copies with their own letters
|
|
|
|
(def ^:private price [[["Price: "] ["$10" {:weight 700}]]])
|
|
|
|
(t/deftest retyped-two-style-copy-takes-the-main-family
|
|
;; the family has one value across the main, so it applies everywhere;
|
|
;; "Sale" shares nothing with "Price: $10" and takes the main's first
|
|
;; letter's weight
|
|
(t/is (= [[["Sale" {:family "Roboto"}]]]
|
|
(sync-text price [[["Sale"]]]
|
|
[[["Price: " {:family "Roboto"}] ["$10" {:family "Roboto" :weight 700}]]]))))
|
|
|
|
(t/deftest copy-that-removes-a-run-takes-the-main-color
|
|
(let [copy [[["$10" {:weight 700}]]]]
|
|
(t/is (= [[["$10" {:weight 700 :color :blue}]]]
|
|
(sync-text price copy
|
|
[[["Price: " {:color :blue}] ["$10" {:weight 700 :color :blue}]]])))))
|
|
|
|
(t/deftest copy-with-new-letters-in-a-run-takes-the-main-family
|
|
(t/is (= [[["Price: " {:family "Roboto"}] ["$20" {:family "Roboto" :weight 700}]]]
|
|
(sync-text price [[["Price: "] ["$20" {:weight 700}]]]
|
|
[[["Price: " {:family "Roboto"}] ["$10" {:family "Roboto" :weight 700}]]]))))
|
|
|
|
(t/deftest copy-with-new-letters-across-runs-takes-a-partial-color
|
|
;; ": $10" is shared, so "$10" takes the red; "Cost" at the start takes
|
|
;; the black of ":"
|
|
(t/is (= [[["Cost: "] ["$10" {:weight 700 :color :red}]]]
|
|
(sync-text price [[["Cost: "] ["$10" {:weight 700}]]]
|
|
[[["Price: "] ["$10" {:weight 700 :color :red}]]]))))
|
|
|
|
(t/deftest copy-with-added-letters-takes-a-partial-color
|
|
;; "world" is shared, so it turns red; "!!!" follows the "d" before it
|
|
(t/is (= [[["Hello "] ["world!!!" {:color :red}]]]
|
|
(sync-text [[["Hello world"]]] [[["Hello world!!!"]]]
|
|
[[["Hello "] ["world" {:color :red}]]]))))
|
|
|
|
(t/deftest copy-with-a-new-price-takes-the-main-bold-on-the-right-letters
|
|
;; "Price: $" is shared; "20" follows the bold "$"
|
|
(t/is (= [[["Price" {:weight 700}] [": "] ["$20" {:weight 700}]]]
|
|
(sync-text price [[["Price: "] ["$20" {:weight 700}]]]
|
|
[[["Price" {:weight 700}] [": "] ["$10" {:weight 700}]]]))))
|
|
|
|
(t/deftest copy-that-adds-a-line-to-a-two-style-title-takes-the-main-family
|
|
;; the new line follows the regular "sale" before it, across the break
|
|
(let [main [[["Summer " {:weight 700}] ["sale"]]]
|
|
copy [[["Summer " {:weight 700}] ["sale"]]
|
|
[["Ends Sunday"]]]]
|
|
(t/is (= [[["Summer " {:family "Roboto" :weight 700}] ["sale" {:family "Roboto"}]]
|
|
[["Ends Sunday" {:family "Roboto"}]]]
|
|
(sync-text main copy
|
|
[[["Summer " {:family "Roboto" :weight 700}] ["sale" {:family "Roboto"}]]])))))
|
|
|
|
(t/deftest copy-with-a-new-line-in-content-without-fills-takes-the-main-color
|
|
;; `txt/change-text` writes nodes with no :fills; the main's still reach
|
|
;; them
|
|
(let [file (-> (sample-file)
|
|
(tho/add-frame-with-text :main-root :main-child "hello world")
|
|
(thc/make-component :component1 :main-root)
|
|
(thc/instantiate-component :component1 :copy-root {:children-labels [:copy-child]}))
|
|
page (thf/current-page file)
|
|
edit (fn [file label f]
|
|
(thf/apply-changes
|
|
file
|
|
(cls/generate-update-shapes (pcb/empty-changes nil (:id page))
|
|
#{(thi/id label)} f (:objects page) {})))
|
|
blue [{:fill-color "#0000FF" :fill-opacity 1}]
|
|
file' (-> file
|
|
(edit :copy-child (fn [shape]
|
|
(update shape :content txt/change-text "hello world\nsecond line")))
|
|
(edit :main-child (fn [shape]
|
|
(update shape :content
|
|
#(txt/transform-nodes txt/is-content-node?
|
|
(fn [node] (assoc node :fills blue))
|
|
%))))
|
|
(tho/propagate-component-changes :component1))]
|
|
(t/is (= [[["hello world" {:color :blue}]] [["second line" {:color :blue}]]]
|
|
(thtx/text-of file' :copy-child)))))
|
|
|
|
;; ---- Typographies and library colors
|
|
|
|
(t/deftest copy-that-resizes-a-typography-text-takes-the-main-color
|
|
;; the size comes from the copy, so the typography no longer describes
|
|
;; the run and goes, also when the copy's content kept it
|
|
(let [main (thtx/apply-typography [[["Read the guide"]]] :body body)
|
|
copy (thtx/restyle main :size 20)
|
|
kept (thtx/apply-typography [[["Read the guide"]]] :body (assoc body :size 20))
|
|
main' (thtx/restyle main :color :blue)]
|
|
(t/testing "detached in the panel before resizing"
|
|
(t/is (= (thtx/normalize (thtx/restyle copy :color :blue))
|
|
(sync-text main copy main'))))
|
|
(t/testing "resized keeping the typography (plugin API)"
|
|
(t/is (= (thtx/normalize (thtx/restyle copy :color :blue))
|
|
(sync-text main kept main'))))))
|
|
|
|
(t/deftest copy-that-detached-a-typography-takes-a-library-change-through-its-main
|
|
(let [body-attrs {:font-id "sourcesanspro" :font-family "sourcesanspro" :font-variant-id "regular"
|
|
:font-size "14" :font-weight "400" :font-style "normal"
|
|
:line-height "1.2" :letter-spacing "0" :text-transform "none"}
|
|
file (-> (thf/sample-file :file1)
|
|
(ths/add-sample-typography :body body-attrs)
|
|
(thtx/add-text-component-with-copy [[["Read the guide" {:typography :body}]]])
|
|
(thtx/set-text :copy-child [[["Read the guide" {:size 16}]]])
|
|
(update :data cttl/update-typography (thi/id :body)
|
|
assoc :font-family "Roboto" :font-id "gfont-roboto"))
|
|
sync (fn [file asset-type asset-id]
|
|
(thf/apply-changes
|
|
file
|
|
(cll/generate-sync-file-changes (pcb/empty-changes) nil asset-type (:id file)
|
|
asset-id (:id file) {(:id file) file} (:id file))))
|
|
file' (-> file
|
|
(sync :typographies (thi/id :body))
|
|
(sync :components (thi/id :component1)))]
|
|
(t/is (= [[["Read the guide" {:family "Roboto" :size 16}]]]
|
|
(thtx/text-of file' :copy-child)))))
|
|
|
|
(t/deftest untouched-copy-with-a-library-color-takes-the-main-size
|
|
;; the library color sync writes the copy's runs; it is derived, so the
|
|
;; main's later size change must still arrive
|
|
(let [brand (fn [color] [{:fill-color color :fill-opacity 1
|
|
:fill-color-ref-id (thi/id :brand)
|
|
:fill-color-ref-file (thi/id :file1)}])
|
|
sync (fn [file asset-type asset-id]
|
|
(thf/apply-changes
|
|
file
|
|
(cll/generate-sync-file-changes (pcb/empty-changes) nil asset-type (:id file)
|
|
asset-id (:id file) {(:id file) file} (:id file))))
|
|
file (-> (thf/sample-file :file1)
|
|
(ths/add-sample-library-color :brand :color "#0000FF"))
|
|
file' (-> file
|
|
(thtx/add-text-component-with-copy [[["New arrivals" {:weight 600 :fills (brand "#0000FF")}]]])
|
|
(assoc-in [:data :colors (thi/id :brand) :color] "#7B3FD1")
|
|
(sync :colors (thi/id :brand))
|
|
(thtx/set-text :main-child [[["New arrivals" {:weight 600 :size 18 :fills (brand "#7B3FD1")}]]])
|
|
(sync :components (thi/id :component1)))]
|
|
(t/is (= [[["New arrivals" {:weight 600 :size 18 :fills (brand "#7B3FD1")}]]]
|
|
(thtx/text-of file' :copy-child)))))
|
|
|
|
;; ---- The worked example: a copy that bolds "Hello" and adds "!!!"
|
|
|
|
(def ^:private worked-copy [[["Hello" {:weight 700}] [" world!!!"]]])
|
|
|
|
(def ^:private worked-example
|
|
"Main edit of \"Hello world\" -> what the copy should hold."
|
|
[["colors all of it blue"
|
|
[[["Hello world" {:color :blue}]]]
|
|
[[["Hello" {:weight 700 :color :blue}] [" world!!!" {:color :blue}]]]]
|
|
|
|
["colors \"world\" red"
|
|
[[["Hello "] ["world" {:color :red}]]]
|
|
[[["Hello" {:weight 700}] [" "] ["world!!!" {:color :red}]]]]
|
|
|
|
["changes the size"
|
|
[[["Hello world" {:size 18}]]]
|
|
[[["Hello" {:weight 700 :size 18}] [" world!!!" {:size 18}]]]]
|
|
|
|
["centers it"
|
|
[[{:align "center"} ["Hello world"]]]
|
|
[[{:align "center"} ["Hello" {:weight 700}] [" world!!!"]]]]
|
|
|
|
["changes the letters to \"Hello there\""
|
|
[[["Hello there"]]]
|
|
worked-copy]
|
|
|
|
["changes the letters to \"Goodbye world\""
|
|
[[["Goodbye world"]]]
|
|
worked-copy]
|
|
|
|
["makes \"world\" light"
|
|
[[["Hello "] ["world" {:weight 300}]]]
|
|
worked-copy]
|
|
|
|
["makes all of it light"
|
|
[[["Hello world" {:weight 300}]]]
|
|
worked-copy]
|
|
|
|
["changes the family"
|
|
[[["Hello world" {:family "Roboto"}]]]
|
|
;; the bold keeps its variant id, for the frontend to pick Roboto's
|
|
[[["Hello" {:family "Roboto" :weight 700 :font-variant-id "bold"}] [" world!!!" {:family "Roboto"}]]]]
|
|
|
|
["applies a typography"
|
|
(thtx/apply-typography [[["Hello world"]]] :heading heading)
|
|
;; the weight is the copy's, so the typography goes; the bold takes
|
|
;; the variant the typography's Inter bold names
|
|
[[{:line-height 1.4}
|
|
["Hello" {:family "Inter" :weight 700 :size 24 :spacing 1 :case "uppercase"}]
|
|
[" world!!!" {:family "Inter" :size 24 :spacing 1 :case "uppercase"}]]]]])
|
|
|
|
(t/deftest copy-that-bolds-a-word-and-adds-letters-against-main-edits
|
|
(doseq [[title main' expected] worked-example]
|
|
(t/testing (str "the main " title)
|
|
(t/is (= (thtx/normalize expected)
|
|
(sync-text [[["Hello world"]]] worked-copy main'))))))
|
|
|
|
;; ---- The same as today
|
|
|
|
(t/deftest relabeled-copy-takes-the-main-size
|
|
(t/is (= [[["Buy now" {:weight 600 :size 18}]]]
|
|
(sync-text [[["Add to cart" {:weight 600}]]]
|
|
[[["Buy now" {:weight 600}]]]
|
|
[[["Add to cart" {:weight 600 :size 18}]]]))))
|
|
|
|
(t/deftest relabeled-copy-keeps-its-letters-when-the-main-relabels
|
|
(t/is (= [[["Buy now" {:weight 600}]]]
|
|
(sync-text [[["Add to cart" {:weight 600}]]]
|
|
[[["Buy now" {:weight 600}]]]
|
|
[[["Add to bag" {:weight 600}]]]))))
|