Penpot/penpot
0
Fork 0
mirror of https://github.com/penpot/penpot.git synced 2025-04-13 07:21:40 -05:00
Code Issues Activity

feat(backend): port icons images and users handlers to new api

Browse source
This commit is contained in:
Andrey Antukh 2019-06-15 18:08:35 +02:00
parent e0600a3058
commit 7400f0f946
9 changed files with 746 additions and 324 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

40
backend/src/uxbox/api.clj
View file

@ -12,6 +12,9 @@
[uxbox.api.middleware :refer [handler router-options]]
[uxbox.api.auth :as api-auth]
[uxbox.api.pages :as api-pages]
[uxbox.api.users :as api-users]
[uxbox.api.icons :as api-icons]
[uxbox.api.images :as api-images]
[uxbox.api.projects :as api-projects]))
;; --- Top Level Handlers
@ -44,6 +47,8 @@
["/projects/by-token/:token" {:get (handler #'api-projects/get-by-share-token)}]
["/projects/:id" {:put (handler #'api-projects/update)
:delete (handler #'api-projects/delete)}]
;; Pages
["/pages" {:get (handler #'api-pages/list)
:post (handler #'api-pages/create)}]
["/pages/:id" {:put (handler #'api-pages/update)
@ -51,6 +56,41 @@
["/pages/:id/metadata" {:put (handler #'api-pages/update-metadata)}]
["/pages/:id/history" {:get (handler #'api-pages/retrieve-history)}]
["/pages/:id/history/:hid" {:put (handler #'api-pages/update-history)}]
;; Profile
["/profile/me" {:get (handler #'api-users/retrieve-profile)
:put (handler #'api-users/update-profile)}]
["/profile/me/password" {:put (handler #'api-users/update-password)}]
["/profile/me/photo" {:post (handler #'api-users/update-photo)}]
;; Library
["/library"
;; Icons
["/icon-collections/:id" {:put (handler #'api-icons/update-collection)
:delete (handler #'api-icons/delete-collection)}]
["/icon-collections" {:get (handler #'api-icons/list-collections)
:post (handler #'api-icons/create-collection)}]
["/icons/:id/copy" {:put (handler #'api-icons/copy-icon)}]
["/icons/:id" {:put (handler #'api-icons/update-icon)
:delete (handler #'api-icons/delete-icon)}]
["/icons" {:post (handler #'api-icons/create-icon)
:get (handler #'api-icons/list-icons)}]
;; Images
["/image-collections/:id" {:put (handler #'api-images/update-collection)
:delete (handler #'api-images/delete-collection)}]
["/image-collections" {:post (handler #'api-images/create-collection)
:get (handler #'api-images/list-collections)}]
["/images/:id/copy" {:put (handler #'api-images/copy-image)}]
["/images/:id" {:get (handler #'api-images/retrieve-image)
:delete (handler #'api-images/delete-image)
:put (handler #'api-images/update-image)}]
["/images" {:post (handler #'api-images/create-image)
:get (handler #'api-images/list-images)}]
]
]]
router-options))

131
backend/src/uxbox/api/icons.clj Normal file
View file

@ -0,0 +1,131 @@
;; 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) 2019 Andrey Antukh <niwi@niwi.nz>
(ns uxbox.api.icons
(:require [struct.core :as st]
[promesa.core :as p]
[uxbox.services :as sv]
[uxbox.util.http :as http]
[uxbox.util.spec :as us]
[uxbox.util.uuid :as uuid]))
(defn create-collection
{:parameters {:body {:name [st/required st/string]
:id [st/uuid]}}}
[{:keys [user parameters]}]
(let [data (get parameters :body)
message (assoc data
:type :create-icon-collection
:user user)]
(->> (sv/novelty message)
(p/map (fn [result]
(let [loc (str "/api/library/icons/" (:id result))]
(http/created loc result)))))))
(defn update-collection
{:parameters {:path {:id [st/required st/uuid-str]}
:body {:name [st/required st/string]
:version [st/required st/integer]
:id [st/uuid]}}}
[{:keys [user parameters]}]
(let [data (get parameters :body)
message (assoc data
:id (get-in parameters [:path :id])
:type :update-icon-collection
:user user)]
(-> (sv/novelty message)
(p/then #(http/ok %)))))
(defn delete-collection
{:parameters {:path {:id [st/required st/uuid-str]}}}
[{:keys [user parameters]}]
(let [message {:id (get-in parameters [:path :id])
:type :delete-icon-collection
:user user}]
(-> (sv/novelty message)
(p/then (fn [v] (http/no-content))))))
(defn list-collections
[{:keys [user]}]
(let [params {:user user :type :list-icon-collections}]
(-> (sv/query params)
(p/then #(http/ok %)))))
;; (def metadata-spec
;; {:width [st/number st/positive]
;; :height [st/number st/positive]
;; :view-box [st/coll [st/every number?]]
;; :mimetype [st/string]})
;; (def metadata-validator
;; {:message "must be a metadata"
;; :optional true
;; :validate #(st/valid? %1 metadata-spec)})
(defn create-icon
{:parameters {:body {:id [st/uuid]
:collection [st/uuid]
:metadata [st/required] ;; TODO
:name [st/required st/string]
:content [st/required st/string]}}}
[{:keys [user parameters]}]
(let [id (or (get-in parameters [:body :id]) (uuid/random))
data (get parameters :body)
message (assoc data
:user user
:id id
:type :create-icon)]
(->> (sv/novelty message)
(p/map (fn [entry]
(let [loc (str "/api/library/icons/" (:id entry))]
(http/created loc entry)))))))
(defn update-icon
{:parameters {:path {:id [st/required st/uuid-str]}
:body {:name [st/required st/string]
:version [st/required st/number]
:collection [st/uuid]}}}
[{:keys [user parameters]}]
(let [data (get parameters :body)
message (assoc data
:id (get-in parameters [:path :id])
:type :update-icon
:user user)]
(->> (sv/novelty message)
(p/map #(http/ok %)))))
(defn copy-icon
{:parameters {:path {:id [st/required st/uuid-str]}
:body {:collection [st/uuid]}}}
[{:keys [user parameters]}]
(let [data (get parameters :body)
message {:collection (get-in parameters [:body :collection])
:id (get-in parameters [:path :id])
:user user
:type :copy-icon}]
(->> (sv/novelty message)
(p/map #(http/ok %)))))
(defn delete-icon
{:parameters {:path {:id [st/required st/uuid-str]}}}
[{:keys [user parameters]}]
(let [message {:id (get-in parameters [:path :id])
:type :delete-icon
:user user}]
(->> (sv/novelty message)
(p/map (fn [v] (http/no-content))))))
(defn list-icons
{:parameters {:query {:collection [st/uuid-str]}}}
[{:keys [user parameters]}]
(let [collection (get-in parameters [:query :collection])
message {:collection collection
:type :list-icons
:user user}]
(->> (sv/query message)
(p/map http/ok))))

169
backend/src/uxbox/api/images.clj Normal file
View file

@ -0,0 +1,169 @@
;; 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) 2019 Andrey Antukh <niwi@niwi.nz>
(ns uxbox.api.images
(:require [struct.core :as st]
[promesa.core :as p]
[datoteka.storages :as ds]
[datoteka.core :as fs]
[uxbox.media :as media]
[uxbox.images :as images]
[uxbox.services :as sv]
[uxbox.util.http :as http]
[uxbox.util.spec :as us]
[uxbox.util.uuid :as uuid]))
(def +thumbnail-options+ {:src :path
:dst :thumbnail
:width 300
:height 100
:quality 92
:format "webp"})
(def populate-thumbnails
#(images/populate-thumbnails % +thumbnail-options+))
(def populate-urls
#(images/populate-urls % media/images-storage :path :url))
(defn create-collection
{:parameters {:body {:name [st/required st/string]
:id [st/uuid]}}}
[{:keys [user parameters]}]
(let [data (get parameters :body)
message (assoc data
:type :create-image-collection
:user user)]
(->> (sv/novelty message)
(p/map (fn [result]
(let [loc (str "/api/library/images/" (:id result))]
(http/created loc result)))))))
(defn update-collection
{:parameters {:path {:id [st/required st/uuid-str]}
:body {:name [st/required st/string]
:version [st/required st/number]
:id [st/uuid]}}}
[{:keys [user parameters]}]
(let [data (get parameters :body)
message (assoc data
:id (get-in parameters [:path :id])
:type :update-image-collection
:user user)]
(-> (sv/novelty message)
(p/then http/ok))))
(defn delete-collection
{:parameters {:path {:id [st/required st/uuid-str]}}}
[{:keys [user parameters]}]
(let [message {:id (get-in parameters [:path :id])
:type :delete-image-collection
:user user}]
(-> (sv/novelty message)
(p/then (constantly (http/no-content))))))
(defn list-collections
[{:keys [user]}]
(let [params {:user user :type :list-image-collections}]
(-> (sv/query params)
(p/then http/ok))))
(defn retrieve-image
{:parameters {:path {:id [st/required st/uuid-str]}}}
[{:keys [user parameters]}]
(let [message {:user user
:type :retrieve-image
:id (get-in parameters [:path :id])}]
(->> (sv/query message)
(p/map (fn [result]
(if result
(-> (populate-thumbnails result)
(populate-urls)
(http/ok))
(http/not-found "")))))))
;; (s/def ::create-image
;; (s/keys :req-un [::file ::width ::height ::mimetype]
;; :opt-un [::us/id ::collection]))
(defn create-image
[{user :identity data :data}]
#_(let [{:keys [file id width height
mimetype collection]} (us/conform ::create-image data)
id (or id (uuid/random))
filename (fs/name file)
storage media/images-storage]
(letfn [(persist-image-entry [path]
(sv/novelty {:id id
:type :create-image
:user user
:width width
:height height
:mimetype mimetype
:collection collection
:name filename
:path (str path)}))
(create-response [entry]
(let [loc (str "/api/library/images/" (:id entry))]
(http/created loc (rsp entry))))]
(->> (st/save storage filename file)
(p/mapcat persist-image-entry)
(p/map populate-thumbnails)
(p/map populate-urls)
(p/map create-response)))))
(defn update-image
{:parameters {:path {:id [st/required st/uuid-str]}
:body {:name [st/required st/string]
:version [st/required st/number]
:collection [st/uuid]}}}
[{:keys [user parameters]}]
(let [data (get parameters :body)
message (assoc data
:id (get-in parameters [:path :id])
:type :update-image
:user user)]
(->> (sv/novelty message)
(p/map populate-thumbnails)
(p/map populate-urls)
(p/map http/ok))))
(defn copy-image
{:parameters {:path {:id [st/required st/uuid-str]}
:body {:collection [st/uuid]}}}
[{:keys [user parameters]}]
(let [message {:id (get-in parameters [:path :id])
:type :copy-image
:collection (get-in parameters [:body :collection])}]
(->> (sv/novelty message)
(p/map populate-thumbnails)
(p/map populate-urls)
(p/map http/ok))))
(defn delete-image
{:parameters {:path {:id [st/required st/uuid-str]}}}
[{:keys [user parameters]}]
(let [message {:id (get-in parameters [:path :id])
:type :delete-image
:user user}]
(->> (sv/novelty message)
(p/map (constantly (http/no-content))))))
;; --- List collections
(defn list-images
{:parameters {:query {:collection [st/uuid-str]}}}
[{:keys [user parameters]}]
(let [collection (get-in parameters [:query :collection])
message {:collection collection
:type :list-images
:user user}]
(->> (sv/query message)
(p/map (partial map populate-thumbnails))
(p/map (partial map populate-urls))
(p/map http/ok))))

2
backend/src/uxbox/api/pages.clj
View file

@ -92,7 +92,7 @@
{:parameters {:path {:id [st/required st/uuid-str]
:hid [st/required st/uuid-str]}
:body {:label [st/required st/string]
::pinned [st/required st/boolean]}}}
:pinned [st/required st/boolean]}}}
[{:keys [user parameters]}]
(let [{:keys [id hid]} (get parameters :path)
message (assoc (get parameters :body)

84
backend/src/uxbox/api/users.clj Normal file
View file

@ -0,0 +1,84 @@
;; 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) 2019 Andrey Antukh <niwi@niwi.nz>
(ns uxbox.api.users
(:require [clojure.spec.alpha :as s]
[struct.core :as st]
[promesa.core :as p]
[datoteka.storages :as ds]
[datoteka.core :as fs]
[uxbox.services :as sv]
[uxbox.media :as media]
[uxbox.images :as images]
[uxbox.util.http :as http]
[uxbox.util.spec :as us]
[uxbox.util.uuid :as uuid]))
;; --- Helpers
(defn- resolve-thumbnail
[user]
(let [opts {:src :photo
:dst :photo
:size [100 100]
:quality 90
:format "jpg"}]
(images/populate-thumbnails user opts)))
(defn retrieve-profile
[{:keys [user]}]
(let [message {:user user :type :retrieve-profile}]
(->> (sv/query message)
(p/map resolve-thumbnail)
(p/map #(http/ok %)))))
(defn update-profile
{:parameters {:body {:username [st/required st/string]
:email [st/required st/email]
:fullname [st/required st/string]
:metadata [st/required]}}}
[{:keys [user parameters]}]
(let [data (get parameters :body)
message (assoc data
:type :update-profile
:user user)]
(->> (sv/novelty message)
(p/map resolve-thumbnail)
(p/map #(http/ok %)))))
(defn update-password
{:parameters {:body {:password [st/required st/string]
:old-password [st/required st/string]}}}
[{:keys [user parameters]}]
(let [data (get parameters :body)
message (assoc data
:type :update-profile-password
:user user)]
(-> (sv/novelty message)
(p/then #(http/ok %)))))
;; TODO: validate {:multipart {:file {:filename "sample.jpg", :content-type "application/octet-stream", :tempfile #file "/tmp/ring-multipart-7913603702731714635.tmp", :size 312043}}}
(defn update-photo
{:parameters {:multipart {:file [st/required]}}}
[{:keys [user parameters] :as ctx}]
(letfn [(store-photo [{:keys [filename tempfile] :as upload}]
(let [filename (fs/name filename)
storage media/images-storage]
(ds/save storage filename tempfile)))
(assign-photo [path]
(sv/novelty {:user user
:path (str path)
:type :update-profile-photo}))]
(->> (get-in parameters [:multipart :file])
(store-photo)
(p/mapcat assign-photo)
(p/map (constantly (http/no-content))))))

1
backend/src/uxbox/frontend.clj
View file

@ -148,7 +148,6 @@
[:put "profile/me" #'users/update-profile]
[:put "profile/me/password" #'users/update-password]
[:post "profile/me/photo" #'users/update-photo]]]))))
;; --- State Initialization
(defn- start-server

286
backend/test/uxbox/tests/test_icons.clj
View file

@ -2,162 +2,160 @@
(:require [clojure.test :as t]
[promesa.core :as p]
[suricatta.core :as sc]
[clj-uuid :as uuid]
[clojure.java.io :as io]
[catacumba.testing :refer (with-server)]
[buddy.core.codecs :as codecs]
[uxbox.db :as db]
[uxbox.sql :as sql]
[uxbox.frontend :as uft]
[uxbox.api :as uapi]
[uxbox.services.icons :as icons]
[uxbox.services :as usv]
[uxbox.tests.helpers :as th]))
;; (t/use-fixtures :each th/database-reset)
(t/use-fixtures :each th/database-reset)
;; (t/deftest test-http-list-icon-collections
;; (with-open [conn (db/connection)]
;; (let [user (th/create-user conn 1)
;; data {:user (:id user)
;; :name "coll1"}
;; coll (icons/create-collection conn data)]
;; (with-server {:handler (uft/routes)}
;; (let [uri (str th/+base-url+ "/api/library/icon-collections")
;; [status data] (th/http-get user uri)]
;; ;; (println "RESPONSE:" status data)
;; (t/is (= 200 status))
;; (t/is (= 1 (count data))))))))
(t/deftest test-http-list-icon-collections
(with-open [conn (db/connection)]
(let [user (th/create-user conn 1)
data {:user (:id user)
:name "coll1"}
coll (icons/create-collection conn data)]
(th/with-server {:handler uapi/app}
(let [uri (str th/+base-url+ "/api/library/icon-collections")
[status data] (th/http-get user uri)]
;; (println "RESPONSE:" status data)
(t/is (= 200 status))
(t/is (= 1 (count data))))))))
;; (t/deftest test-http-create-icon-collection
;; (with-open [conn (db/connection)]
;; (let [user (th/create-user conn 1)]
;; (with-server {:handler (uft/routes)}
;; (let [uri (str th/+base-url+ "/api/library/icon-collections")
;; data {:user (:id user)
;; :name "coll1"}
;; params {:body data}
;; [status data] (th/http-post user uri params)]
;; ;; (println "RESPONSE:" status data)
;; (t/is (= 201 status))
;; (t/is (= (:user data) (:id user)))
;; (t/is (= (:name data) "coll1")))))))
(t/deftest test-http-create-icon-collection
(with-open [conn (db/connection)]
(let [user (th/create-user conn 1)]
(th/with-server {:handler uapi/app}
(let [uri (str th/+base-url+ "/api/library/icon-collections")
data {:user (:id user)
:name "coll1"}
params {:body data}
[status data] (th/http-post user uri params)]
;; (println "RESPONSE:" status data)
(t/is (= 201 status))
(t/is (= (:user data) (:id user)))
(t/is (= (:name data) "coll1")))))))
;; (t/deftest test-http-update-icon-collection
;; (with-open [conn (db/connection)]
;; (let [user (th/create-user conn 1)
;; data {:user (:id user)
;; :name "coll1"}
;; coll (icons/create-collection conn data)]
;; (with-server {:handler (uft/routes)}
;; (let [uri (str th/+base-url+ "/api/library/icon-collections/" (:id coll))
;; params {:body (assoc coll :name "coll2")}
;; [status data] (th/http-put user uri params)]
;; ;; (println "RESPONSE:" status data)
;; (t/is (= 200 status))
;; (t/is (= (:user data) (:id user)))
;; (t/is (= (:name data) "coll2")))))))
(t/deftest test-http-update-icon-collection
(with-open [conn (db/connection)]
(let [user (th/create-user conn 1)
data {:user (:id user)
:name "coll1"}
coll (icons/create-collection conn data)]
(th/with-server {:handler uapi/app}
(let [uri (str th/+base-url+ "/api/library/icon-collections/" (:id coll))
params {:body (assoc coll :name "coll2")}
[status data] (th/http-put user uri params)]
;; (println "RESPONSE:" status data)
(t/is (= 200 status))
(t/is (= (:user data) (:id user)))
(t/is (= (:name data) "coll2")))))))
;; (t/deftest test-http-icon-collection-delete
;; (with-open [conn (db/connection)]
;; (let [user (th/create-user conn 1)
;; data {:user (:id user)
;; :name "coll1"
;; :data #{1}}
;; coll (icons/create-collection conn data)]
;; (with-server {:handler (uft/routes)}
;; (let [uri (str th/+base-url+ "/api/library/icon-collections/" (:id coll))
;; [status data] (th/http-delete user uri)]
;; (t/is (= 204 status))
;; (let [sqlv (sql/get-icon-collections {:user (:id user)})
;; result (sc/fetch conn sqlv)]
;; (t/is (empty? result))))))))
(t/deftest test-http-icon-collection-delete
(with-open [conn (db/connection)]
(let [user (th/create-user conn 1)
data {:user (:id user)
:name "coll1"
:data #{1}}
coll (icons/create-collection conn data)]
(th/with-server {:handler uapi/app}
(let [uri (str th/+base-url+ "/api/library/icon-collections/" (:id coll))
[status data] (th/http-delete user uri)]
(t/is (= 204 status))
(let [sqlv (sql/get-icon-collections {:user (:id user)})
result (sc/fetch conn sqlv)]
(t/is (empty? result))))))))
;; (t/deftest test-http-create-icon
;; (with-open [conn (db/connection)]
;; (let [user (th/create-user conn 1)]
;; (with-server {:handler (uft/routes)}
;; (let [uri (str th/+base-url+ "/api/library/icons")
;; data {:name "sample.jpg"
;; :content "<g></g>"
;; :metadata {:width 200
;; :height 200
;; :view-box [0 0 200 200]}
;; :collection nil}
;; params {:body data}
;; [status data] (th/http-post user uri params)]
;; ;; (println "RESPONSE:" status data)
;; (t/is (= 201 status))
;; (t/is (= (:user data) (:id user)))
;; (t/is (= (:name data) "sample.jpg"))
;; (t/is (= (:metadata data) {:width 200
;; :height 200
;; :view-box [0 0 200 200]})))))))
(t/deftest test-http-create-icon
(with-open [conn (db/connection)]
(let [user (th/create-user conn 1)]
(th/with-server {:handler uapi/app}
(let [uri (str th/+base-url+ "/api/library/icons")
data {:name "sample.jpg"
:content "<g></g>"
:metadata {:width 200
:height 200
:view-box [0 0 200 200]}
:collection nil}
params {:body data}
[status data] (th/http-post user uri params)]
;; (println "RESPONSE:" status data)
(t/is (= 201 status))
(t/is (= (:user data) (:id user)))
(t/is (= (:name data) "sample.jpg"))
(t/is (= (:metadata data) {:width 200
:height 200
:view-box [0 0 200 200]})))))))
;; (t/deftest test-http-update-icon
;; (with-open [conn (db/connection)]
;; (let [user (th/create-user conn 1)
;; data {:user (:id user)
;; :name "test.svg"
;; :content "<g></g>"
;; :metadata {}
;; :collection nil}
;; icon (icons/create-icon conn data)]
;; (with-server {:handler (uft/routes)}
;; (let [uri (str th/+base-url+ "/api/library/icons/" (:id icon))
;; params {:body (assoc icon :name "my stuff")}
;; [status data] (th/http-put user uri params)]
;; ;; (println "RESPONSE:" status data)
;; (t/is (= 200 status))
;; (t/is (= (:user data) (:id user)))
;; (t/is (= (:name data) "my stuff")))))))
(t/deftest test-http-update-icon
(with-open [conn (db/connection)]
(let [user (th/create-user conn 1)
data {:user (:id user)
:name "test.svg"
:content "<g></g>"
:metadata {}
:collection nil}
icon (icons/create-icon conn data)]
(th/with-server {:handler uapi/app}
(let [uri (str th/+base-url+ "/api/library/icons/" (:id icon))
params {:body (assoc icon :name "my stuff")}
[status data] (th/http-put user uri params)]
;; (println "RESPONSE:" status data)
(t/is (= 200 status))
(t/is (= (:user data) (:id user)))
(t/is (= (:name data) "my stuff")))))))
;; (t/deftest test-http-copy-icon
;; (with-open [conn (db/connection)]
;; (let [user (th/create-user conn 1)
;; data {:user (:id user)
;; :name "test.svg"
;; :content "<g></g>"
;; :metadata {}
;; :collection nil}
;; icon (icons/create-icon conn data)]
;; (with-server {:handler (uft/routes)}
;; (let [uri (str th/+base-url+ "/api/library/icons/copy")
;; body {:id (:id icon) :collection nil}
;; params {:body body}
;; [status data] (th/http-put user uri params)]
;; (println "RESPONSE:" status data)
;; (let [sqlv (sql/get-icons {:user (:id user) :collection nil})
;; result (sc/fetch conn sqlv)]
;; (t/is (= 2 (count result)))))))))
(t/deftest test-http-copy-icon
(with-open [conn (db/connection)]
(let [user (th/create-user conn 1)
data {:user (:id user)
:name "test.svg"
:content "<g></g>"
:metadata {}
:collection nil}
icon (icons/create-icon conn data)]
(th/with-server {:handler uapi/app}
(let [uri (str th/+base-url+ "/api/library/icons/" (:id icon) "/copy")
body {:collection nil}
params {:body body}
[status data] (th/http-put user uri params)]
;; (println "RESPONSE:" status data)
(t/is (= status 200))
(let [sqlv (sql/get-icons {:user (:id user) :collection nil})
result (sc/fetch conn sqlv)]
(t/is (= 2 (count result)))))))))
;; (t/deftest test-http-delete-icon
;; (with-open [conn (db/connection)]
;; (let [user (th/create-user conn 1)
;; data {:user (:id user)
;; :name "test.svg"
;; :content "<g></g>"
;; :metadata {}
;; :collection nil}
;; icon (icons/create-icon conn data)]
;; (with-server {:handler (uft/routes)}
;; (let [uri (str th/+base-url+ "/api/library/icons/" (:id icon))
;; [status data] (th/http-delete user uri)]
;; (t/is (= 204 status))
;; (let [sqlv (sql/get-icons {:user (:id user) :collection nil})
;; result (sc/fetch conn sqlv)]
;; (t/is (empty? result))))))))
(t/deftest test-http-delete-icon
(with-open [conn (db/connection)]
(let [user (th/create-user conn 1)
data {:user (:id user)
:name "test.svg"
:content "<g></g>"
:metadata {}
:collection nil}
icon (icons/create-icon conn data)]
(th/with-server {:handler uapi/app}
(let [uri (str th/+base-url+ "/api/library/icons/" (:id icon))
[status data] (th/http-delete user uri)]
(t/is (= 204 status))
(let [sqlv (sql/get-icons {:user (:id user) :collection nil})
result (sc/fetch conn sqlv)]
(t/is (empty? result))))))))
;; ;; (t/deftest test-http-list-icons
;; ;; (with-open [conn (db/connection)]
;; ;; (let [user (th/create-user conn 1)
;; ;; data {:user (:id user)
;; ;; :name "test.png"
;; ;; :path "some/path"
;; ;; :collection nil}
;; ;; icon (icons/create-icon conn data)]
;; ;; (with-server {:handler (uft/routes)}
;; ;; (let [uri (str th/+base-url+ "/api/library/icons")
;; ;; [status data] (th/http-get user uri)]
;; ;; (println "RESPONSE:" status data)
;; ;; (t/is (= 200 status))
;; ;; (t/is (= 1 (count data))))))))
(t/deftest test-http-list-icons
(with-open [conn (db/connection)]
(let [user (th/create-user conn 1)
data {:user (:id user)
:name "test.png"
:content "<g></g>"
:metadata {}
:collection nil}
icon (icons/create-icon conn data)]
(th/with-server {:handler uapi/app}
(let [uri (str th/+base-url+ "/api/library/icons")
[status data] (th/http-get user uri)]
;; (println "RESPONSE:" status data)
(t/is (= 200 status))
(t/is (= 1 (count data))))))))

268
backend/test/uxbox/tests/test_images.clj
View file

@ -3,74 +3,73 @@
[promesa.core :as p]
[suricatta.core :as sc]
[clojure.java.io :as io]
[catacumba.testing :refer (with-server)]
[datoteka.storages :as st]
[uxbox.db :as db]
[uxbox.sql :as sql]
[uxbox.media :as media]
[uxbox.frontend :as uft]
[uxbox.api :as uapi]
[uxbox.services.images :as images]
[uxbox.services :as usv]
[uxbox.tests.helpers :as th]))
;; (t/use-fixtures :each th/database-reset)
(t/use-fixtures :each th/database-reset)
;; (t/deftest test-http-list-image-collections
;; (with-open [conn (db/connection)]
;; (let [user (th/create-user conn 1)
;; data {:user (:id user)
;; :name "coll1"}
;; coll (images/create-collection conn data)]
;; (with-server {:handler (uft/routes)}
;; (let [uri (str th/+base-url+ "/api/library/image-collections")
;; [status data] (th/http-get user uri)]
;; ;; (println "RESPONSE:" status data)
;; (t/is (= 200 status))
;; (t/is (= 1 (count data))))))))
(t/deftest test-http-list-image-collections
(with-open [conn (db/connection)]
(let [user (th/create-user conn 1)
data {:user (:id user)
:name "coll1"}
coll (images/create-collection conn data)]
(th/with-server {:handler uapi/app}
(let [uri (str th/+base-url+ "/api/library/image-collections")
[status data] (th/http-get user uri)]
;; (println "RESPONSE:" status data)
(t/is (= 200 status))
(t/is (= 1 (count data))))))))
;; (t/deftest test-http-create-image-collection
;; (with-open [conn (db/connection)]
;; (let [user (th/create-user conn 1)]
;; (with-server {:handler (uft/routes)}
;; (let [uri (str th/+base-url+ "/api/library/image-collections")
;; data {:user (:id user)
;; :name "coll1"}
;; params {:body data}
;; [status data] (th/http-post user uri params)]
;; ;; (println "RESPONSE:" status data)
;; (t/is (= 201 status))
;; (t/is (= (:user data) (:id user)))
;; (t/is (= (:name data) "coll1")))))))
(t/deftest test-http-create-image-collection
(with-open [conn (db/connection)]
(let [user (th/create-user conn 1)]
(th/with-server {:handler uapi/app}
(let [uri (str th/+base-url+ "/api/library/image-collections")
data {:user (:id user)
:name "coll1"}
params {:body data}
[status data] (th/http-post user uri params)]
;; (println "RESPONSE:" status data)
(t/is (= 201 status))
(t/is (= (:user data) (:id user)))
(t/is (= (:name data) "coll1")))))))
;; (t/deftest test-http-update-image-collection
;; (with-open [conn (db/connection)]
;; (let [user (th/create-user conn 1)
;; data {:user (:id user)
;; :name "coll1"}
;; coll (images/create-collection conn data)]
;; (with-server {:handler (uft/routes)}
;; (let [uri (str th/+base-url+ "/api/library/image-collections/" (:id coll))
;; params {:body (assoc coll :name "coll2")}
;; [status data] (th/http-put user uri params)]
;; ;; (println "RESPONSE:" status data)
;; (t/is (= 200 status))
;; (t/is (= (:user data) (:id user)))
;; (t/is (= (:name data) "coll2")))))))
(t/deftest test-http-update-image-collection
(with-open [conn (db/connection)]
(let [user (th/create-user conn 1)
data {:user (:id user)
:name "coll1"}
coll (images/create-collection conn data)]
(th/with-server {:handler uapi/app}
(let [uri (str th/+base-url+ "/api/library/image-collections/" (:id coll))
params {:body (assoc coll :name "coll2")}
[status data] (th/http-put user uri params)]
;; (println "RESPONSE:" status data)
(t/is (= 200 status))
(t/is (= (:user data) (:id user)))
(t/is (= (:name data) "coll2")))))))
;; (t/deftest test-http-image-collection-delete
;; (with-open [conn (db/connection)]
;; (let [user (th/create-user conn 1)
;; data {:user (:id user)
;; :name "coll1"
;; :data #{1}}
;; coll (images/create-collection conn data)]
;; (with-server {:handler (uft/routes)}
;; (let [uri (str th/+base-url+ "/api/library/image-collections/" (:id coll))
;; [status data] (th/http-delete user uri)]
;; (t/is (= 204 status))
;; (let [sqlv (sql/get-image-collections {:user (:id user)})
;; result (sc/fetch conn sqlv)]
;; (t/is (empty? result))))))))
(t/deftest test-http-image-collection-delete
(with-open [conn (db/connection)]
(let [user (th/create-user conn 1)
data {:user (:id user)
:name "coll1"
:data #{1}}
coll (images/create-collection conn data)]
(th/with-server {:handler uapi/app}
(let [uri (str th/+base-url+ "/api/library/image-collections/" (:id coll))
[status data] (th/http-delete user uri)]
(t/is (= 204 status))
(let [sqlv (sql/get-image-collections {:user (:id user)})
result (sc/fetch conn sqlv)]
(t/is (empty? result))))))))
;; ;; (t/deftest test-http-create-image
;; ;; (with-open [conn (db/connection)]
@ -87,83 +86,86 @@
;; ;; (t/is (= (:user data) (:id user)))
;; ;; (t/is (= (:name data) "sample.jpg")))))))
;; (t/deftest test-http-update-image
;; (with-open [conn (db/connection)]
;; (let [user (th/create-user conn 1)
;; data {:user (:id user)
;; :name "test.png"
;; :path "some/path"
;; :width 100
;; :height 100
;; :mimetype "image/png"
;; :collection nil}
;; img (images/create-image conn data)]
;; (with-server {:handler (uft/routes)}
;; (let [uri (str th/+base-url+ "/api/library/images/" (:id img))
;; params {:body (assoc img :name "my stuff")}
;; [status data] (th/http-put user uri params)]
;; ;; (println "RESPONSE:" status data)
;; (t/is (= 200 status))
;; (t/is (= (:user data) (:id user)))
;; (t/is (= (:name data) "my stuff")))))))
(t/deftest test-http-update-image
(with-open [conn (db/connection)]
(let [user (th/create-user conn 1)
data {:user (:id user)
:name "test.png"
:path "some/path"
:width 100
:height 100
:mimetype "image/png"
:collection nil}
img (images/create-image conn data)]
(th/with-server {:handler uapi/app}
(let [uri (str th/+base-url+ "/api/library/images/" (:id img))
params {:body (assoc img :name "my stuff")}
[status data] (th/http-put user uri params)]
;; (println "RESPONSE:" status data)
(t/is (= 200 status))
(t/is (= (:user data) (:id user)))
(t/is (= (:name data) "my stuff")))))))
;; (t/deftest test-http-copy-image
;; (with-open [conn (db/connection)]
;; (let [user (th/create-user conn 1)
;; storage media/images-storage
;; filename "sample.jpg"
;; rcs (io/resource "uxbox/tests/_files/sample.jpg")
;; path @(st/save storage filename rcs)
;; data {:user (:id user)
;; :name filename
;; :path (str path)
;; :width 100
;; :height 100
;; :mimetype "image/jpg"
;; :collection nil}
;; img (images/create-image conn data)]
;; (with-server {:handler (uft/routes)}
;; (let [uri (str th/+base-url+ "/api/library/images/copy")
;; body {:id (:id img)
;; :collection nil}
;; params {:body body}
;; [status data] (th/http-put user uri params)]
;; ;; (println "RESPONSE:" status data)
;; (t/is (= 200 status))
;; (let [sqlv (sql/get-images {:user (:id user) :collection nil})
;; result (sc/fetch conn sqlv)]
;; (t/is (= 2 (count result)))))))))
(t/deftest test-http-copy-image
(with-open [conn (db/connection)]
(let [user (th/create-user conn 1)
storage media/images-storage
filename "sample.jpg"
rcs (io/resource "uxbox/tests/_files/sample.jpg")
path @(st/save storage filename rcs)
data {:user (:id user)
:name filename
:path (str path)
:width 100
:height 100
:mimetype "image/jpg"
:collection nil}
img (images/create-image conn data)]
(th/with-server {:handler uapi/app}
(let [uri (str th/+base-url+ "/api/library/images/" (:id img) "/copy")
body {:id (:id img)
:collection nil}
params {:body body}
[status data] (th/http-put user uri params)]
;; (println "RESPONSE:" status data)
(t/is (= 200 status))
(let [sqlv (sql/get-images {:user (:id user) :collection nil})
result (sc/fetch conn sqlv)]
(t/is (= 2 (count result)))))))))
;; (t/deftest test-http-delete-image
;; (with-open [conn (db/connection)]
;; (let [user (th/create-user conn 1)
;; data {:user (:id user)
;; :name "test.png"
;; :path "some/path"
;; :width 100
;; :height 100
;; :mimetype "image/png"
;; :collection nil}
;; img (images/create-image conn data)]
;; (with-server {:handler (uft/routes)}
;; (let [uri (str th/+base-url+ "/api/library/images/" (:id img))
;; [status data] (th/http-delete user uri)]
;; (t/is (= 204 status))
;; (let [sqlv (sql/get-images {:user (:id user) :collection nil})
;; result (sc/fetch conn sqlv)]
;; (t/is (empty? result))))))))
(t/deftest test-http-delete-image
(with-open [conn (db/connection)]
(let [user (th/create-user conn 1)
data {:user (:id user)
:name "test.png"
:path "some/path"
:width 100
:height 100
:mimetype "image/png"
:collection nil}
img (images/create-image conn data)]
(th/with-server {:handler uapi/app}
(let [uri (str th/+base-url+ "/api/library/images/" (:id img))
[status data] (th/http-delete user uri)]
(t/is (= 204 status))
(let [sqlv (sql/get-images {:user (:id user) :collection nil})
result (sc/fetch conn sqlv)]
(t/is (empty? result))))))))
;; ;; (t/deftest test-http-list-images
;; ;; (with-open [conn (db/connection)]
;; ;; (let [user (th/create-user conn 1)
;; ;; data {:user (:id user)
;; ;; :name "test.png"
;; ;; :path "some/path"
;; ;; :collection nil}
;; ;; img (images/create-image conn data)]
;; ;; (with-server {:handler (uft/routes)}
;; ;; (let [uri (str th/+base-url+ "/api/library/images")
;; ;; [status data] (th/http-get user uri)]
;; ;; (println "RESPONSE:" status data)
;; ;; (t/is (= 200 status))
;; ;; (t/is (= 1 (count data))))))))
(t/deftest test-http-list-images
(with-open [conn (db/connection)]
(let [user (th/create-user conn 1)
data {:user (:id user)
:name "test.png"
:path "some/path"
:width 100
:height 100
:mimetype "image/png"
:collection nil}
img (images/create-image conn data)]
(th/with-server {:handler uapi/app}
(let [uri (str th/+base-url+ "/api/library/images")
[status data] (th/http-get user uri)]
(println "RESPONSE:" status data)
(t/is (= 200 status))
(t/is (= 1 (count data))))))))

89
backend/test/uxbox/tests/test_users.clj
View file

@ -5,60 +5,59 @@
[buddy.hashers :as hashers]
[clj-http.client :as http]
[suricatta.core :as sc]
[catacumba.testing :refer (with-server)]
[uxbox.db :as db]
[uxbox.frontend :as uft]
[uxbox.api :as uapi]
[uxbox.services.users :as usu]
[uxbox.services :as usv]
[uxbox.tests.helpers :as th]))
(t/use-fixtures :each th/database-reset)
;; (t/deftest test-http-retrieve-profile
;; (with-open [conn (db/connection)]
;; (let [user (th/create-user conn 1)]
;; (with-server {:handler (uft/routes)}
;; (let [uri (str th/+base-url+ "/api/profile/me")
;; [status data] (th/http-get user uri)]
;; ;; (println "RESPONSE:" status data)
;; (t/is (= 200 status))
;; (t/is (= (:fullname data) "User 1"))
;; (t/is (= (:username data) "user1"))
;; (t/is (= (:metadata data) "1"))
;; (t/is (= (:email data) "user1@uxbox.io"))
;; (t/is (not (contains? data :password))))))))
(t/deftest test-http-retrieve-profile
(with-open [conn (db/connection)]
(let [user (th/create-user conn 1)]
(th/with-server {:handler uapi/app}
(let [uri (str th/+base-url+ "/api/profile/me")
[status data] (th/http-get user uri)]
;; (println "RESPONSE:" status data)
(t/is (= 200 status))
(t/is (= (:fullname data) "User 1"))
(t/is (= (:username data) "user1"))
(t/is (= (:metadata data) "1"))
(t/is (= (:email data) "user1@uxbox.io"))
(t/is (not (contains? data :password))))))))
;; (t/deftest test-http-update-profile
;; (with-open [conn (db/connection)]
;; (let [user (th/create-user conn 1)]
;; (with-server {:handler (uft/routes)}
;; (let [uri (str th/+base-url+ "/api/profile/me")
;; data (assoc user
;; :fullname "Full Name"
;; :username "user222"
;; :metadata "222"
;; :email "user222@uxbox.io")
;; [status data] (th/http-put user uri {:body data})]
;; ;; (println "RESPONSE:" status data)
;; (t/is (= 200 status))
;; (t/is (= (:fullname data) "Full Name"))
;; (t/is (= (:username data) "user222"))
;; (t/is (= (:metadata data) "222"))
;; (t/is (= (:email data) "user222@uxbox.io"))
;; (t/is (not (contains? data :password))))))))
(t/deftest test-http-update-profile
(with-open [conn (db/connection)]
(let [user (th/create-user conn 1)]
(th/with-server {:handler uapi/app}
(let [uri (str th/+base-url+ "/api/profile/me")
data (assoc user
:fullname "Full Name"
:username "user222"
:metadata "222"
:email "user222@uxbox.io")
[status data] (th/http-put user uri {:body data})]
;; (println "RESPONSE:" status data)
(t/is (= 200 status))
(t/is (= (:fullname data) "Full Name"))
(t/is (= (:username data) "user222"))
(t/is (= (:metadata data) "222"))
(t/is (= (:email data) "user222@uxbox.io"))
(t/is (not (contains? data :password))))))))
;; (t/deftest test-http-update-profile-photo
;; (with-open [conn (db/connection)]
;; (let [user (th/create-user conn 1)]
;; (with-server {:handler (uft/routes)}
;; (let [uri (str th/+base-url+ "/api/profile/me/photo")
;; params [{:name "sample.jpg"
;; :part-name "file"
;; :content (io/input-stream
;; (io/resource "uxbox/tests/_files/sample.jpg"))}]
;; [status data] (th/http-multipart user uri params)]
;; ;; (println "RESPONSE:" status data)
;; (t/is (= 204 status)))))))
(t/deftest test-http-update-profile-photo
(with-open [conn (db/connection)]
(let [user (th/create-user conn 1)]
(th/with-server {:handler uapi/app}
(let [uri (str th/+base-url+ "/api/profile/me/photo")
params [{:name "sample.jpg"
:part-name "file"
:content (io/input-stream
(io/resource "uxbox/tests/_files/sample.jpg"))}]
[status data] (th/http-multipart user uri params)]
;; (println "RESPONSE:" status data)
(t/is (= 204 status)))))))
;; (t/deftest test-http-register-user
;; (with-server {:handler (uft/routes)}