Penpot/penpot
0
Fork 0
mirror of https://github.com/penpot/penpot.git synced 2025-01-08 07:50:43 -05:00
Code Issues Activity

Fix all tests.

Browse source
This commit is contained in:
Andrey Antukh 2017-03-01 20:09:14 +01:00
parent 8245ea0bdc
commit d474712cd6
No known key found for this signature in database
GPG key ID: 4DFEBCB8316A8B95
4 changed files with 532 additions and 516 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
frontend/test/uxbox/tests/main.cljs
View file

@ -1,7 +1,7 @@
(ns uxbox.tests.main
(:require [cljs.test :as test]
[uxbox.tests.geom-types]
[uxbox.tests.shapes-state]))
[uxbox.tests.test-util-geom]
[uxbox.tests.test-main-data-shapes-impl]))
(enable-console-print!)
@ -9,8 +9,8 @@
[]
(test/run-tests
(test/empty-env)
'uxbox.tests.geom-types
'uxbox.tests.shapes-state
'uxbox.tests.test-util-geom
'uxbox.tests.test-main-data-shapes-impl
))
(defmethod test/report [:cljs.test/default :end-run-tests]

510
frontend/test/uxbox/tests/shapes_state.cljs
View file

@ -1,510 +0,0 @@
(ns uxbox.tests.shapes-state
(:require [cljs.test :as t :include-macros true]
[cljs.pprint :refer (pprint)]
[uxbox.util.uuid :as uuid]
[uxbox.main.state.shapes :as sh]))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Duplicate (one shape)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defn constantly-inc
[init]
(let [v (atom init)]
(fn [& args]
(let [result @v]
(swap! v inc)
result))))
;; duplicate shape: duplicate simple shape
(t/deftest duplicate-shapes-test1
(let [initial {:pages-by-id {1 {:id 1 :shapes [1]}}
:shapes-by-id {1 {:id 1 :page 1}}}
expected (-> initial
(assoc-in [:pages-by-id 1 :shapes] [2 1])
(assoc-in [:shapes-by-id 2] {:id 2 :page 1}))]
(with-redefs [uxbox.util.uuid/random (constantly 2)]
(let [result (sh/duplicate-shapes initial [1])]
;; (pprint expected)
;; (pprint result)
(t/is (= result expected))))))
;; duplicate shape: duplicate inside group
(t/deftest duplicate-shapes-test2
(let [initial {:pages-by-id {1 {:id 1 :shapes [1]}}
:shapes-by-id {1 {:id 1 :name "1" :page 1
:type :group
:items [2 3]}
2 {:id 2 :name "2" :page 1 :group 1}
3 {:id 3 :name "3" :page 1 :group 1}}}
expected (-> initial
(assoc-in [:shapes-by-id 1 :items] [5 4 2 3])
(assoc-in [:shapes-by-id 4] {:id 4 :name "3" :page 1 :group 1})
(assoc-in [:shapes-by-id 5] {:id 5 :name "2" :page 1 :group 1}))]
(with-redefs [uxbox.util.uuid/random (constantly-inc 4)]
(let [result (sh/duplicate-shapes initial [2 3])]
;; (pprint expected)
;; (pprint result)
(t/is (= result expected))))))
;; duplicate shape: duplicate mixed bag
(t/deftest duplicate-shapes-test3
(let [initial {:pages-by-id {1 {:id 1 :shapes [1 4]}}
:shapes-by-id {1 {:id 1 :name "1" :page 1
:type :group
:items [2 3]}
2 {:id 2 :name "2" :page 1 :group 1}
3 {:id 3 :name "3" :page 1 :group 1}
4 {:id 4 :name "4" :page 1}}}
expected (-> initial
(assoc-in [:pages-by-id 1 :shapes] [6 5 1 4])
(assoc-in [:shapes-by-id 5] {:id 5 :name "4" :page 1})
(assoc-in [:shapes-by-id 6] {:id 6 :name "3" :page 1}))]
(with-redefs [uxbox.util.uuid/random (constantly-inc 5)]
(let [result (sh/duplicate-shapes initial [3 4])]
;; (pprint expected)
;; (pprint result)
(t/is (= result expected))))))
;; duplicate shape: duplicate one group
(t/deftest duplicate-shapes-test4
(let [initial {:pages-by-id {1 {:id 1 :shapes [1]}}
:shapes-by-id {1 {:id 1 :page 1
:type :group
:items [2]}
2 {:id 3 :page 1 :group 1}}}
expected (-> initial
(assoc-in [:pages-by-id 1 :shapes] [3 1])
(assoc-in [:shapes-by-id 3] {:id 3 :page 1
:type :group
:items [4]})
(assoc-in [:shapes-by-id 4] {:id 4 :page 1 :group 3}))]
(with-redefs [uxbox.util.uuid/random (constantly-inc 3)]
(let [result (sh/duplicate-shapes initial [1])]
;; (pprint expected)
;; (pprint result)
(t/is (= result expected))))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Drop Shape (drag and drop and sorted)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; drop shape: move shape before other shape
(t/deftest drop-shape-test1
(let [initial {:pages-by-id {1 {:id 1 :shapes [1 2 3]}}
:shapes-by-id {1 {:id 1 :page 1}
2 {:id 2 :page 1}
3 {:id 3 :page 1}}}
expected (assoc-in initial [:pages-by-id 1 :shapes] [3 1 2])
result (sh/drop-shape initial 3 1 :before)]
;; (pprint expected)
;; (pprint result)
(t/is (= result expected))
(t/is (vector? (get-in result [:pages-by-id 1 :shapes])))))
;; drop shape: move shape after other shape
(t/deftest drop-shape-test2
(let [initial {:pages-by-id {1 {:id 1 :shapes [1 2 3]}}
:shapes-by-id {1 {:id 1 :page 1}
2 {:id 2 :page 1}
3 {:id 3 :page 1}}}
expected (assoc-in initial [:pages-by-id 1 :shapes] [1 3 2])
result (sh/drop-shape initial 3 1 :after)]
(t/is (= result expected))
(t/is (vector? (get-in result [:pages-by-id 1 :shapes])))))
;; drop shape: move shape before other shape that is part of group.
(t/deftest drop-shape-test3
(let [initial {:pages-by-id {1 {:id 1 :shapes [1 3 4]}}
:shapes-by-id {1 {:id 1 :page 1
:type :group
:items [2]}
2 {:id 2 :page 1 :group 1}
3 {:id 3 :page 1}
4 {:id 4 :page 1}}}
expected (-> initial
(assoc-in [:pages-by-id 1 :shapes] [1 4])
(assoc-in [:shapes-by-id 1 :items] [3 2])
(assoc-in [:shapes-by-id 3 :group] 1))
result (sh/drop-shape initial 3 2 :before)]
(t/is (= result expected))
(t/is (vector? (get-in result [:pages-by-id 1 :shapes])))))
;; drop shape: move shape inside group
(t/deftest drop-shape-test4
(let [initial {:pages-by-id {1 {:id 1 :shapes [1 3 4]}}
:shapes-by-id {1 {:id 1 :page 1
:type :group
:items [2]}
2 {:id 2 :page 1 :group 1}
3 {:id 3 :page 1}
4 {:id 4 :page 1}}}
expected (-> initial
(assoc-in [:pages-by-id 1 :shapes] [1 4])
(assoc-in [:shapes-by-id 1 :items] [2 3])
(assoc-in [:shapes-by-id 3 :group] 1))
result (sh/drop-shape initial 3 1 :inside)]
;; (pprint expected)
;; (pprint result)
(t/is (= result expected))
(t/is (vector? (get-in result [:pages-by-id 1 :shapes])))))
;; drop shape: move shape outside of group
(t/deftest drop-shape-test5
(let [initial {:pages-by-id {1 {:id 1 :shapes [1 4]}}
:shapes-by-id {1 {:id 1 :page 1
:type :group
:items [2 3]}
2 {:id 2 :page 1 :group 1}
3 {:id 3 :page 1 :group 1}
4 {:id 4 :page 1}}}
expected (-> initial
(assoc-in [:pages-by-id 1 :shapes] [1 4 3])
(assoc-in [:shapes-by-id 1 :items] [2])
(update-in [:shapes-by-id 3] dissoc :group))
result (sh/drop-shape initial 3 4 :after)]
(t/is (= result expected))
(t/is (vector? (get-in result [:pages-by-id 1 :shapes])))))
;; drop shape: move group inside group
(t/deftest drop-shape-test6
(let [initial {:pages-by-id {1 {:id 1 :shapes [1 2]}}
:shapes-by-id {1 {:id 1 :page 1
:type :group
:items [3]}
2 {:id 2 :page 1
:type :group
:items [4]}
3 {:id 3 :page 1 :group 1}
4 {:id 4 :page 1 :group 2}}}
expected (-> initial
(assoc-in [:pages-by-id 1 :shapes] [1])
(assoc-in [:shapes-by-id 1 :items] [3 2])
(assoc-in [:shapes-by-id 2 :group] 1))
result (sh/drop-shape initial 2 3 :after)]
;; (pprint expected)
;; (pprint result)
(t/is (= result expected))
(t/is (vector? (get-in result [:pages-by-id 1 :shapes])))))
;; drop shape: move group outside group
(t/deftest drop-shape-test7
(let [initial {:pages-by-id {1 {:id 1 :shapes [1 3]}}
:shapes-by-id {1 {:id 1 :page 1
:type :group
:items [2]}
2 {:id 2 :page 1
:group 1
:type :group
:items [4]}
3 {:id 3 :page 1}
4 {:id 4 :page 1 :group 2}}}
expected (-> initial
(assoc-in [:pages-by-id 1 :shapes] [2 3])
(update-in [:shapes-by-id] dissoc 1)
(update-in [:shapes-by-id 2] dissoc :group))
result (sh/drop-shape initial 2 1 :after)]
;; (pprint expected)
;; (pprint result)
(t/is (= result expected))
(t/is (vector? (get-in result [:pages-by-id 1 :shapes])))))
;; drop shape: move shape to neested group
(t/deftest drop-shape-test8
(let [initial {:pages-by-id {1 {:id 1 :shapes [1 5 6]}}
:shapes-by-id {1 {:id 1 :page 1
:type :group
:items [2]}
2 {:id 2 :page 1
:group 1
:type :group
:items [3 4]}
3 {:id 3 :page 1 :group 2}
4 {:id 4 :page 1 :group 2}
5 {:id 5 :page 1}
6 {:id 6 :page 1}}}
expected (-> initial
(assoc-in [:pages-by-id 1 :shapes] [1 5])
(update-in [:shapes-by-id 2 :items] conj 6)
(update-in [:shapes-by-id 6] assoc :group 2))
result (sh/drop-shape initial 6 4 :after)]
;; (pprint expected)
;; (pprint result)
(t/is (= result expected))))
;; drop shape: move shape to neested group
(t/deftest drop-shape-test9
(let [initial {:pages-by-id {1 {:id 1 :shapes [1]}}
:shapes-by-id {1 {:id 1 :page 1
:type :group
:items [2 5 6]}
2 {:id 2 :page 1
:group 1
:type :group
:items [3 4]}
3 {:id 3 :page 1 :group 2}
4 {:id 4 :page 1 :group 2}
5 {:id 5 :page 1 :group 1}
6 {:id 6 :page 1 :group 1}}}
expected (-> initial
(assoc-in [:pages-by-id 1 :shapes] [1])
(assoc-in [:shapes-by-id 2 :items] [3 4 6])
(assoc-in [:shapes-by-id 1 :items] [2 5])
(update-in [:shapes-by-id 6] assoc :group 2))
result (sh/drop-shape initial 6 4 :after)]
;; (pprint expected)
;; (pprint result)
(t/is (= result expected))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Delete Shape
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; delete shape: delete from page
(t/deftest delete-shape-test1
(let [initial {:pages-by-id {1 {:id 1 :shapes [1 3 4]}}
:shapes-by-id {1 {:id 1 :page 1
:type :group
:items [2]}
2 {:id 2 :page 1 :group 1}
3 {:id 3 :page 1}
4 {:id 4 :page 1}}}
shape (get-in initial [:shapes-by-id 4])
expected (-> initial
(assoc-in [:pages-by-id 1 :shapes] [1 3])
(update-in [:shapes-by-id] dissoc 4))
result (sh/dissoc-shape initial shape)]
;; (pprint expected)
;; (pprint result)
(t/is (= result expected))))
;; delete shape: delete from group
(t/deftest delete-shape-test2
(let [initial {:pages-by-id {1 {:id 1 :shapes [1 3 4]}}
:shapes-by-id {1 {:id 1 :page 1
:type :group
:items [2]}
2 {:id 2 :page 1 :group 1}
3 {:id 3 :page 1}
4 {:id 4 :page 1}}}
shape (get-in initial [:shapes-by-id 2])
expected (-> initial
(assoc-in [:pages-by-id 1 :shapes] [3 4])
(update-in [:shapes-by-id] dissoc 2)
(update-in [:shapes-by-id] dissoc 1))
result (sh/dissoc-shape initial shape)]
;; (pprint expected)
;; (pprint result)
(t/is (= result expected))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Group Shapes
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; group a shape
(t/deftest group-shapes-1
(let [initial {:pages-by-id {1 {:id 1 :shapes [1 2 3]}}
:shapes-by-id {1 {:id 1 :page 1}
2 {:id 2 :page 1}
3 {:id 3 :page 1}}}
expected (-> initial
(assoc-in [:workspace :selected] #{4})
(assoc-in [:pages-by-id 1 :shapes] [1 4 3])
(assoc-in [:shapes-by-id 2 :group] 4)
(assoc-in [:shapes-by-id 4] {:type :group :name "Group 10"
:items [2] :id 4 :page 1}))]
(with-redefs [uxbox.util.uuid/random (constantly 4)
cljs.core/rand-int (constantly 10)]
(let [result (sh/group-shapes initial [2] 1)]
(t/is (= result expected))))))
;; group two shapes
(t/deftest group-shapes-2
(let [initial {:pages-by-id {1 {:id 1 :shapes [1 2 3]}}
:shapes-by-id {1 {:id 1 :page 1}
2 {:id 2 :page 1}
3 {:id 3 :page 1}}}
expected (-> initial
(assoc-in [:workspace :selected] #{4})
(assoc-in [:pages-by-id 1 :shapes] [1 4])
(assoc-in [:shapes-by-id 2 :group] 4)
(assoc-in [:shapes-by-id 3 :group] 4)
(assoc-in [:shapes-by-id 4] {:type :group :name "Group 10"
:items [2 3] :id 4 :page 1}))]
(with-redefs [uxbox.util.uuid/random (constantly 4)
cljs.core/rand-int (constantly 10)]
(let [result (sh/group-shapes initial [2 3] 1)]
(t/is (= result expected))))))
;; group group
(t/deftest group-shapes-3
(let [initial {:pages-by-id {1 {:id 1 :shapes [1 2 3]}}
:shapes-by-id {1 {:id 1 :page 1}
2 {:id 2 :page 1}
3 {:id 3 :page 1 :type :group}}}
expected (-> initial
(assoc-in [:workspace :selected] #{4})
(assoc-in [:pages-by-id 1 :shapes] [1 4])
(assoc-in [:shapes-by-id 2 :group] 4)
(assoc-in [:shapes-by-id 3 :group] 4)
(assoc-in [:shapes-by-id 4] {:type :group :name "Group 10"
:items [2 3] :id 4 :page 1}))]
(with-redefs [uxbox.util.uuid/random (constantly 4)
cljs.core/rand-int (constantly 10)]
(let [result (sh/group-shapes initial [2 3] 1)]
(t/is (= result expected))))))
;; group shapes inside a group
(t/deftest group-shapes-4
(let [initial {:pages-by-id {1 {:id 1 :shapes [1 3]}}
:shapes-by-id {1 {:id 1 :page 1}
2 {:id 2 :page 1 :group 3}
3 {:id 3 :page 1 :type :group}}}
expected (-> initial
(assoc-in [:workspace :selected] #{4})
(assoc-in [:pages-by-id 1 :shapes] [1 3])
(assoc-in [:shapes-by-id 2 :group] 4)
(assoc-in [:shapes-by-id 3 :items] [4])
(assoc-in [:shapes-by-id 4] {:type :group :name "Group 10"
:items [2] :id 4 :page 1 :group 3}))]
(with-redefs [uxbox.util.uuid/random (constantly 4)
cljs.core/rand-int (constantly 10)]
(let [result (sh/group-shapes initial [2] 1)]
(t/is (= result expected))))))
;; group shapes in multiple groups
(t/deftest group-shapes-5
(let [initial {:pages-by-id {1 {:id 1 :shapes [3 4]}}
:shapes-by-id {1 {:id 1 :page 1 :group 4}
2 {:id 2 :page 1 :group 3}
3 {:id 3 :page 1 :type :group :items [2]}
4 {:id 4 :page 1 :type :group :imtes [3]}}}
expected (-> initial
(assoc-in [:workspace :selected] #{5})
(assoc-in [:pages-by-id 1 :shapes] [5])
(assoc-in [:shapes-by-id 1 :group] 5)
(assoc-in [:shapes-by-id 2 :group] 5)
(assoc-in [:shapes-by-id 5] {:type :group :name "Group 10"
:items [1 2] :id 5 :page 1})
(update-in [:shapes-by-id] dissoc 3)
(update-in [:shapes-by-id] dissoc 4))]
(with-redefs [uxbox.util.uuid/random (constantly 5)
cljs.core/rand-int (constantly 10)]
(let [result (sh/group-shapes initial [1 2] 1)]
(t/is (= result expected))))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Degroups
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; degroup a single group
;; degroup group
(t/deftest degroup-shapes-1
(let [initial {:pages-by-id {1 {:id 1 :shapes [3]}}
:shapes-by-id {1 {:id 1 :page 1 :group 3}
2 {:id 2 :page 1 :group 3}
3 {:id 3 :page 1 :type :group :items [1 2]}}}
expected (-> initial
(assoc-in [:workspace :selected] #{1 2})
(assoc-in [:pages-by-id 1 :shapes] [1 2])
(update-in [:shapes-by-id 1] dissoc :group)
(update-in [:shapes-by-id 2] dissoc :group)
(update-in [:shapes-by-id] dissoc 3))]
(let [result (sh/degroup-shapes initial [3] 1)]
(t/is (= result expected)))))
;; degroup group inside a group
(t/deftest degroup-shapes-2
(let [initial {:pages-by-id {1 {:id 1 :shapes [1]}}
:shapes-by-id {1 {:id 1 :page 1 :type :group :items [2]}
2 {:id 2 :page 1 :type :group :items [3] :group 1}
3 {:id 3 :page 1 :group 2}}}
expected (-> initial
(assoc-in [:workspace :selected] #{3})
(assoc-in [:pages-by-id 1 :shapes] [1])
(update-in [:shapes-by-id] dissoc 2)
(assoc-in [:shapes-by-id 1 :items] [3])
(assoc-in [:shapes-by-id 3 :group] 1))]
(let [result (sh/degroup-shapes initial [2] 1)]
(t/is (= result expected)))))
;; degroup multiple groups not nested
(t/deftest degroup-shapes-3
(let [initial {:pages-by-id {1 {:id 1 :shapes [1 2]}}
:shapes-by-id {1 {:id 1 :page 1 :type :group :items [3]}
2 {:id 2 :page 1 :type :group :items [4]}
3 {:id 3 :page 1 :group 1}
4 {:id 4 :page 1 :group 2}}}
expected (-> initial
(assoc-in [:workspace :selected] #{3 4})
(assoc-in [:pages-by-id 1 :shapes] [3 4])
(update :shapes-by-id dissoc 1)
(update :shapes-by-id dissoc 2)
(update-in [:shapes-by-id 3] dissoc :group)
(update-in [:shapes-by-id 4] dissoc :group))]
(let [result (sh/degroup-shapes initial [1 2] 1)]
(t/is (= result expected)))))
;; degroup multiple groups nested (child first)
(t/deftest degroup-shapes-4
(let [initial {:pages-by-id {1 {:id 1 :shapes [1]}}
:shapes-by-id {1 {:id 1 :page 1 :type :group :items [2]}
2 {:id 2 :page 1 :type :group :items [3] :group 1}
3 {:id 3 :page 1 :group 2}}}
expected (-> initial
(assoc-in [:workspace :selected] #{3})
(assoc-in [:pages-by-id 1 :shapes] [3])
(update :shapes-by-id dissoc 1)
(update :shapes-by-id dissoc 2)
(update-in [:shapes-by-id 3] dissoc :group))]
(let [result (sh/degroup-shapes initial [2 1] 1)]
(t/is (= result expected)))))
;; degroup multiple groups nested (parent first)
(t/deftest degroup-shapes-5
(let [initial {:pages-by-id {1 {:id 1 :shapes [1]}}
:shapes-by-id {1 {:id 1 :page 1 :type :group :items [2]}
2 {:id 2 :page 1 :type :group :items [3] :group 1}
3 {:id 3 :page 1 :group 2}}}
expected (-> initial
(assoc-in [:workspace :selected] #{3})
(assoc-in [:pages-by-id 1 :shapes] [3])
(update :shapes-by-id dissoc 1)
(update :shapes-by-id dissoc 2)
(update-in [:shapes-by-id 3] dissoc :group))]
(let [result (sh/degroup-shapes initial [1 2] 1)]
(t/is (= result expected)))))

526
frontend/test/uxbox/tests/test_main_data_shapes_impl.cljs Normal file
View file

@ -0,0 +1,526 @@
(ns uxbox.tests.test-main-data-shapes-impl
(:require [cljs.test :as t :include-macros true]
[cljs.pprint :refer [pprint]]
[uxbox.util.uuid :as uuid]
[uxbox.main.data.shapes-impl :as impl]))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Duplicate (one shape)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defn constantly-inc
[init]
(let [v (atom init)]
(fn [& args]
(let [result @v]
(swap! v inc)
result))))
;; duplicate shape: duplicate simple shape
(t/deftest duplicate-shapes-test1
(let [initial {:pages {1 {:id 1 :shapes [1]}}
:shapes {1 {:id 1 :page 1 :name "a"}}}
expected (-> initial
(assoc-in [:pages 1 :shapes] [2 1])
(assoc-in [:shapes 2] {:id 2 :page 1 :name "a-copy-1"}))]
(with-redefs [uxbox.util.uuid/random (constantly 2)]
(let [result (impl/duplicate-shapes initial [1])]
;; (pprint expected)
;; (pprint result)
(t/is (= result expected))))))
;; duplicate shape: duplicate inside group
(t/deftest duplicate-shapes-test2
(let [initial {:pages {1 {:id 1 :shapes [1]}}
:shapes {1 {:id 1 :name "1" :page 1
:type :group
:items [2 3]}
2 {:id 2 :name "2" :page 1 :group 1}
3 {:id 3 :name "3" :page 1 :group 1}}}
expected (-> initial
(assoc-in [:shapes 1 :items] [5 4 2 3])
(assoc-in [:shapes 4] {:id 4 :name "3-copy-1" :page 1 :group 1})
(assoc-in [:shapes 5] {:id 5 :name "2-copy-1" :page 1 :group 1}))]
(with-redefs [uxbox.util.uuid/random (constantly-inc 4)]
(let [result (impl/duplicate-shapes initial [2 3])]
;; (pprint expected)
;; (pprint result)
(t/is (= result expected))))))
;; duplicate shape: duplicate mixed bag
(t/deftest duplicate-shapes-test3
(let [initial {:pages {1 {:id 1 :shapes [1 4]}}
:shapes {1 {:id 1 :name "1" :page 1
:type :group
:items [2 3]}
2 {:id 2 :name "2" :page 1 :group 1}
3 {:id 3 :name "3" :page 1 :group 1}
4 {:id 4 :name "4" :page 1}}}
expected (-> initial
(assoc-in [:pages 1 :shapes] [6 5 1 4])
(assoc-in [:shapes 5] {:id 5 :name "4-copy-1" :page 1})
(assoc-in [:shapes 6] {:id 6 :name "3-copy-1" :page 1}))]
(with-redefs [uxbox.util.uuid/random (constantly-inc 5)]
(let [result (impl/duplicate-shapes initial [3 4])]
;; (pprint expected)
;; (pprint result)
(t/is (= result expected))))))
;; duplicate shape: duplicate one group
(t/deftest duplicate-shapes-test4
(let [initial {:pages {1 {:id 1 :shapes [1]}}
:shapes {1 {:id 1
:name "1"
:page 1
:type :group
:items [2]}
2 {:id 2
:name "2"
:page 1
:group 1}}}
expected (-> initial
(assoc-in [:pages 1 :shapes] [3 1])
(assoc-in [:shapes 3] {:id 3
:name "1-copy-1"
:page 1
:type :group
:items [4]})
(assoc-in [:shapes 4] {:id 4
:name "2-copy-1"
:page 1
:group 3}))]
(with-redefs [uxbox.util.uuid/random (constantly-inc 3)]
(let [result (impl/duplicate-shapes initial [1])]
;; (pprint expected)
;; (pprint result)
(t/is (= result expected))))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Drop Shape (drag and drop and sorted)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; drop shape: move shape before other shape
(t/deftest drop-shape-test1
(let [initial {:pages {1 {:id 1 :shapes [1 2 3]}}
:shapes {1 {:id 1 :page 1}
2 {:id 2 :page 1}
3 {:id 3 :page 1}}}
expected (assoc-in initial [:pages 1 :shapes] [3 1 2])
result (impl/drop-shape initial 3 1 :before)]
;; (pprint expected)
;; (pprint result)
(t/is (= result expected))
(t/is (vector? (get-in result [:pages 1 :shapes])))))
;; drop shape: move shape after other shape
(t/deftest drop-shape-test2
(let [initial {:pages {1 {:id 1 :shapes [1 2 3]}}
:shapes {1 {:id 1 :page 1}
2 {:id 2 :page 1}
3 {:id 3 :page 1}}}
expected (assoc-in initial [:pages 1 :shapes] [1 3 2])
result (impl/drop-shape initial 3 1 :after)]
(t/is (= result expected))
(t/is (vector? (get-in result [:pages 1 :shapes])))))
;; drop shape: move shape before other shape that is part of group.
(t/deftest drop-shape-test3
(let [initial {:pages {1 {:id 1 :shapes [1 3 4]}}
:shapes {1 {:id 1 :page 1
:type :group
:items [2]}
2 {:id 2 :page 1 :group 1}
3 {:id 3 :page 1}
4 {:id 4 :page 1}}}
expected (-> initial
(assoc-in [:pages 1 :shapes] [1 4])
(assoc-in [:shapes 1 :items] [3 2])
(assoc-in [:shapes 3 :group] 1))
result (impl/drop-shape initial 3 2 :before)]
(t/is (= result expected))
(t/is (vector? (get-in result [:pages 1 :shapes])))))
;; drop shape: move shape inside group
(t/deftest drop-shape-test4
(let [initial {:pages {1 {:id 1 :shapes [1 3 4]}}
:shapes {1 {:id 1 :page 1
:type :group
:items [2]}
2 {:id 2 :page 1 :group 1}
3 {:id 3 :page 1}
4 {:id 4 :page 1}}}
expected (-> initial
(assoc-in [:pages 1 :shapes] [1 4])
(assoc-in [:shapes 1 :items] [2 3])
(assoc-in [:shapes 3 :group] 1))
result (impl/drop-shape initial 3 1 :inside)]
;; (pprint expected)
;; (pprint result)
(t/is (= result expected))
(t/is (vector? (get-in result [:pages 1 :shapes])))))
;; drop shape: move shape outside of group
(t/deftest drop-shape-test5
(let [initial {:pages {1 {:id 1 :shapes [1 4]}}
:shapes {1 {:id 1 :page 1
:type :group
:items [2 3]}
2 {:id 2 :page 1 :group 1}
3 {:id 3 :page 1 :group 1}
4 {:id 4 :page 1}}}
expected (-> initial
(assoc-in [:pages 1 :shapes] [1 4 3])
(assoc-in [:shapes 1 :items] [2])
(update-in [:shapes 3] dissoc :group))
result (impl/drop-shape initial 3 4 :after)]
(t/is (= result expected))
(t/is (vector? (get-in result [:pages 1 :shapes])))))
;; drop shape: move group inside group
(t/deftest drop-shape-test6
(let [initial {:pages {1 {:id 1 :shapes [1 2]}}
:shapes {1 {:id 1 :page 1
:type :group
:items [3]}
2 {:id 2 :page 1
:type :group
:items [4]}
3 {:id 3 :page 1 :group 1}
4 {:id 4 :page 1 :group 2}}}
expected (-> initial
(assoc-in [:pages 1 :shapes] [1])
(assoc-in [:shapes 1 :items] [3 2])
(assoc-in [:shapes 2 :group] 1))
result (impl/drop-shape initial 2 3 :after)]
;; (pprint expected)
;; (pprint result)
(t/is (= result expected))
(t/is (vector? (get-in result [:pages 1 :shapes])))))
;; drop shape: move group outside group
(t/deftest drop-shape-test7
(let [initial {:pages {1 {:id 1 :shapes [1 3]}}
:shapes {1 {:id 1 :page 1
:type :group
:items [2]}
2 {:id 2 :page 1
:group 1
:type :group
:items [4]}
3 {:id 3 :page 1}
4 {:id 4 :page 1 :group 2}}}
expected (-> initial
(assoc-in [:pages 1 :shapes] [2 3])
(update-in [:shapes] dissoc 1)
(update-in [:shapes 2] dissoc :group))
result (impl/drop-shape initial 2 1 :after)]
;; (pprint expected)
;; (pprint result)
(t/is (= result expected))
(t/is (vector? (get-in result [:pages 1 :shapes])))))
;; drop shape: move shape to neested group
(t/deftest drop-shape-test8
(let [initial {:pages {1 {:id 1 :shapes [1 5 6]}}
:shapes {1 {:id 1 :page 1
:type :group
:items [2]}
2 {:id 2 :page 1
:group 1
:type :group
:items [3 4]}
3 {:id 3 :page 1 :group 2}
4 {:id 4 :page 1 :group 2}
5 {:id 5 :page 1}
6 {:id 6 :page 1}}}
expected (-> initial
(assoc-in [:pages 1 :shapes] [1 5])
(update-in [:shapes 2 :items] conj 6)
(update-in [:shapes 6] assoc :group 2))
result (impl/drop-shape initial 6 4 :after)]
;; (pprint expected)
;; (pprint result)
(t/is (= result expected))))
;; drop shape: move shape to neested group
(t/deftest drop-shape-test9
(let [initial {:pages {1 {:id 1 :shapes [1]}}
:shapes {1 {:id 1 :page 1
:type :group
:items [2 5 6]}
2 {:id 2 :page 1
:group 1
:type :group
:items [3 4]}
3 {:id 3 :page 1 :group 2}
4 {:id 4 :page 1 :group 2}
5 {:id 5 :page 1 :group 1}
6 {:id 6 :page 1 :group 1}}}
expected (-> initial
(assoc-in [:pages 1 :shapes] [1])
(assoc-in [:shapes 2 :items] [3 4 6])
(assoc-in [:shapes 1 :items] [2 5])
(update-in [:shapes 6] assoc :group 2))
result (impl/drop-shape initial 6 4 :after)]
;; (pprint expected)
;; (pprint result)
(t/is (= result expected))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Delete Shape
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; delete shape: delete from page
(t/deftest delete-shape-test1
(let [initial {:pages {1 {:id 1 :shapes [1 3 4]}}
:shapes {1 {:id 1 :page 1
:type :group
:items [2]}
2 {:id 2 :page 1 :group 1}
3 {:id 3 :page 1}
4 {:id 4 :page 1}}}
shape (get-in initial [:shapes 4])
expected (-> initial
(assoc-in [:pages 1 :shapes] [1 3])
(update-in [:shapes] dissoc 4))
result (impl/dissoc-shape initial shape)]
;; (pprint expected)
;; (pprint result)
(t/is (= result expected))))
;; delete shape: delete from group
(t/deftest delete-shape-test2
(let [initial {:pages {1 {:id 1 :shapes [1 3 4]}}
:shapes {1 {:id 1 :page 1
:type :group
:items [2]}
2 {:id 2 :page 1 :group 1}
3 {:id 3 :page 1}
4 {:id 4 :page 1}}}
shape (get-in initial [:shapes 2])
expected (-> initial
(assoc-in [:pages 1 :shapes] [3 4])
(update-in [:shapes] dissoc 2)
(update-in [:shapes] dissoc 1))
result (impl/dissoc-shape initial shape)]
;; (pprint expected)
;; (pprint result)
(t/is (= result expected))))
;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; ;; Group Shapes
;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; group a shape
(t/deftest group-shapes-1
(let [initial {:pages {1 {:id 1 :shapes [1 2 3]}}
:shapes {1 {:id 1 :page 1}
2 {:id 2 :page 1}
3 {:id 3 :page 1}}}
expected (-> initial
(assoc-in [:workspace :selected] #{4})
(assoc-in [:pages 1 :shapes] [1 4 3])
(assoc-in [:shapes 2 :group] 4)
(assoc-in [:shapes 4] {:type :group :name "Group-1"
:items [2] :id 4 :page 1}))]
(with-redefs [uxbox.util.uuid/random (constantly 4)]
(let [result (impl/group-shapes initial [2] 1)]
;; (pprint expected)
;; (pprint result)
(t/is (= result expected))))))
;; group two shapes
(t/deftest group-shapes-2
(let [initial {:pages {1 {:id 1 :shapes [1 2 3]}}
:shapes {1 {:id 1 :page 1}
2 {:id 2 :page 1}
3 {:id 3 :page 1}}}
expected (-> initial
(assoc-in [:workspace :selected] #{4})
(assoc-in [:pages 1 :shapes] [1 4])
(assoc-in [:shapes 2 :group] 4)
(assoc-in [:shapes 3 :group] 4)
(assoc-in [:shapes 4] {:type :group :name "Group-1"
:items [2 3] :id 4 :page 1}))]
(with-redefs [uxbox.util.uuid/random (constantly 4)]
(let [result (impl/group-shapes initial [2 3] 1)]
;; (pprint expected)
;; (pprint result)
(t/is (= result expected))))))
;; group group
(t/deftest group-shapes-3
(let [initial {:pages {1 {:id 1 :shapes [1 2 3]}}
:shapes {1 {:id 1 :page 1}
2 {:id 2 :page 1}
3 {:id 3 :page 1 :type :group}}}
expected (-> initial
(assoc-in [:workspace :selected] #{4})
(assoc-in [:pages 1 :shapes] [1 4])
(assoc-in [:shapes 2 :group] 4)
(assoc-in [:shapes 3 :group] 4)
(assoc-in [:shapes 4] {:type :group :name "Group-1"
:items [2 3] :id 4 :page 1}))]
(with-redefs [uxbox.util.uuid/random (constantly 4)]
(let [result (impl/group-shapes initial [2 3] 1)]
;; (pprint expected)
;; (pprint result)
(t/is (= result expected))))))
;; group shapes inside a group
(t/deftest group-shapes-4
(let [initial {:pages {1 {:id 1 :shapes [1 3]}}
:shapes {1 {:id 1 :page 1}
2 {:id 2 :page 1 :group 3}
3 {:id 3 :page 1 :type :group}}}
expected (-> initial
(assoc-in [:workspace :selected] #{4})
(assoc-in [:pages 1 :shapes] [1 3])
(assoc-in [:shapes 2 :group] 4)
(assoc-in [:shapes 3 :items] [4])
(assoc-in [:shapes 4] {:type :group :name "Group-1"
:items [2] :id 4 :page 1 :group 3}))]
(with-redefs [uxbox.util.uuid/random (constantly 4)]
(let [result (impl/group-shapes initial [2] 1)]
;; (pprint expected)
;; (pprint result)
(t/is (= result expected))))))
;; group shapes in multiple groups
(t/deftest group-shapes-5
(let [initial {:pages {1 {:id 1 :shapes [3 4]}}
:shapes {1 {:id 1 :page 1 :group 4}
2 {:id 2 :page 1 :group 3}
3 {:id 3 :page 1 :type :group :items [2]}
4 {:id 4 :page 1 :type :group :imtes [3]}}}
expected (-> initial
(assoc-in [:workspace :selected] #{5})
(assoc-in [:pages 1 :shapes] [5])
(assoc-in [:shapes 1 :group] 5)
(assoc-in [:shapes 2 :group] 5)
(assoc-in [:shapes 5] {:type :group :name "Group-1"
:items [1 2] :id 5 :page 1})
(update-in [:shapes] dissoc 3)
(update-in [:shapes] dissoc 4))]
(with-redefs [uxbox.util.uuid/random (constantly 5)]
(let [result (impl/group-shapes initial [1 2] 1)]
;; (pprint expected)
;; (pprint result)
(t/is (= result expected))))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Degroups
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; degroup a single group
(t/deftest degroup-shapes-1
(let [initial {:pages {1 {:id 1 :shapes [3]}}
:shapes {1 {:id 1 :page 1 :group 3}
2 {:id 2 :page 1 :group 3}
3 {:id 3 :page 1 :type :group :items [1 2]}}}
expected (-> initial
(assoc-in [:workspace :selected] #{1 2})
(assoc-in [:pages 1 :shapes] [1 2])
(update-in [:shapes 1] dissoc :group)
(update-in [:shapes 2] dissoc :group)
(update-in [:shapes] dissoc 3))]
(let [result (impl/degroup-shapes initial [3] 1)]
;; (pprint expected)
;; (pprint result)
(t/is (= result expected)))))
;; degroup group inside a group
(t/deftest degroup-shapes-2
(let [initial {:pages {1 {:id 1 :shapes [1]}}
:shapes {1 {:id 1 :page 1 :type :group :items [2]}
2 {:id 2 :page 1 :type :group :items [3] :group 1}
3 {:id 3 :page 1 :group 2}}}
expected (-> initial
(assoc-in [:workspace :selected] #{3})
(assoc-in [:pages 1 :shapes] [1])
(update-in [:shapes] dissoc 2)
(assoc-in [:shapes 1 :items] [3])
(assoc-in [:shapes 3 :group] 1))]
(let [result (impl/degroup-shapes initial [2] 1)]
;; (pprint expected)
;; (pprint result)
(t/is (= result expected)))))
;; degroup multiple groups not nested
(t/deftest degroup-shapes-3
(let [initial {:pages {1 {:id 1 :shapes [1 2]}}
:shapes {1 {:id 1 :page 1 :type :group :items [3]}
2 {:id 2 :page 1 :type :group :items [4]}
3 {:id 3 :page 1 :group 1}
4 {:id 4 :page 1 :group 2}}}
expected (-> initial
(assoc-in [:workspace :selected] #{3 4})
(assoc-in [:pages 1 :shapes] [3 4])
(update :shapes dissoc 1)
(update :shapes dissoc 2)
(update-in [:shapes 3] dissoc :group)
(update-in [:shapes 4] dissoc :group))]
(let [result (impl/degroup-shapes initial [1 2] 1)]
;; (pprint expected)
;; (pprint result)
(t/is (= result expected)))))
;; degroup multiple groups nested (child first)
(t/deftest degroup-shapes-4
(let [initial {:pages {1 {:id 1 :shapes [1]}}
:shapes {1 {:id 1 :page 1 :type :group :items [2]}
2 {:id 2 :page 1 :type :group :items [3] :group 1}
3 {:id 3 :page 1 :group 2}}}
expected (-> initial
(assoc-in [:workspace :selected] #{3})
(assoc-in [:pages 1 :shapes] [3])
(update :shapes dissoc 1)
(update :shapes dissoc 2)
(update-in [:shapes 3] dissoc :group))]
(let [result (impl/degroup-shapes initial [2 1] 1)]
;; (pprint expected)
;; (pprint result)
(t/is (= result expected)))))
;; degroup multiple groups nested (parent first)
(t/deftest degroup-shapes-5
(let [initial {:pages {1 {:id 1 :shapes [1]}}
:shapes {1 {:id 1 :page 1 :type :group :items [2]}
2 {:id 2 :page 1 :type :group :items [3] :group 1}
3 {:id 3 :page 1 :group 2}}}
expected (-> initial
(assoc-in [:workspace :selected] #{3})
(assoc-in [:pages 1 :shapes] [3])
(update :shapes dissoc 1)
(update :shapes dissoc 2)
(update-in [:shapes 3] dissoc :group))]
(let [result (impl/degroup-shapes initial [1 2] 1)]
;; (pprint expected)
;; (pprint result)
(t/is (= result expected)))))

4
frontend/test/uxbox/tests/geom_types.cljs → frontend/test/uxbox/tests/test_util_geom.cljs
View file

@ -1,6 +1,6 @@
(ns uxbox.tests.geom-types
(ns uxbox.tests.test-util-geom
(:require [cljs.test :as t :include-macros true]
[cljs.pprint :refer (pprint)]
[cljs.pprint :refer [pprint]]
[uxbox.util.geom.point :as gpt]
[uxbox.util.geom.matrix :as gmt]))