luciano/reitit
1
0
Fork 0
mirror of https://github.com/metosin/reitit.git synced 2025-12-17 08:21:11 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge pull request #137 from metosin/interceptors

Browse source 
Interceptors
This commit is contained in:
Tommi Reiman 2018-09-02 17:50:14 +03:00 committed by GitHub
commit 48504bf71e
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
6 changed files with 288 additions and 84 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
examples/pedestal/src/example/server.clj
View file

@ -1,7 +1,7 @@
(ns example.server
(:require [io.pedestal.http]
[clojure.core.async :as a]
[reitit.pedestal :as pedestal]
[reitit.interceptor.pedestal :as pedestal]
[reitit.http :as http]
[reitit.ring :as ring]))
@ -24,7 +24,7 @@
(http/router
["/api"
{:interceptors [[interceptor :api]
[interceptor :apa]]}
[interceptor :ipa]]}
["/sync"
{:interceptors [[interceptor :sync]]

2
examples/pedestal/src/reitit/pedestal.clj → examples/pedestal/src/reitit/interceptor/pedestal.clj
View file

@ -1,4 +1,4 @@
(ns reitit.pedestal
(ns reitit.interceptor.pedestal
(:require [io.pedestal.interceptor.chain :as chain]
[io.pedestal.interceptor :as interceptor]
[io.pedestal.http :as http]

11
modules/reitit-http/src/reitit/http.cljc
View file

@ -89,14 +89,16 @@
context))}))
(defn ring-handler
"Creates a ring-handler out of a http-router,
a default ring-handler and options map, with the following keys:
"Creates a ring-handler out of a http-router, optional default ring-handler
and options map, with the following keys:
| key | description |
| ----------------|-------------|
| `:executor` | `reitit.interceptor.Executor` for the interceptor chain
| `:interceptors` | Optional sequence of interceptors that are always run before any other interceptors, even for the default handler"
[router default-handler {:keys [executor interceptors]}]
([router opts]
(ring-handler router nil opts))
([router default-handler {:keys [executor interceptors]}]
(let [default-handler (or default-handler (fn ([_]) ([_ respond _] (respond nil))))
default-queue (->> [default-handler]
(concat interceptors)
@ -104,6 +106,7 @@
(interceptor/queue executor))
router-opts (-> (r/options router)
(assoc ::interceptor/queue (partial interceptor/queue executor))
(dissoc :data) ; data is already merged into routes
(cond-> (seq interceptors)
(update-in [:data :interceptors] (partial into (vec interceptors)))))
router (reitit.http/router (r/routes router) router-opts)]
@ -142,7 +145,7 @@
(default request)))
(default request)))
nil))
{::r/router router})))
{::r/router router}))))
(defn get-router [handler]
(-> handler meta ::r/router))

21
modules/reitit-http/src/reitit/http/coercion.cljc
View file

@ -3,40 +3,43 @@
[reitit.spec :as rs]
[reitit.impl :as impl]))
(def coerce-request-interceptor
(defn coerce-request-interceptor
"Interceptor for pluggable request coercion.
Expects a :coercion of type `reitit.coercion/Coercion`
and :parameters from route data, otherwise does not mount."
[]
{:name ::coerce-request
:spec ::rs/parameters
:compile (fn [{:keys [coercion parameters]} opts]
(if (and coercion parameters)
(let [coercers (coercion/request-coercers coercion parameters opts)]
{:enter
(fn [ctx]
{:enter (fn [ctx]
(let [request (:request ctx)
coerced (coercion/coerce-request coercers request)
request (impl/fast-assoc request :parameters coerced)]
(assoc ctx :request request)))})))})
(def coerce-response-interceptor
(defn coerce-response-interceptor
"Interceptor for pluggable response coercion.
Expects a :coercion of type `reitit.coercion/Coercion`
and :responses from route data, otherwise does not mount."
[]
{:name ::coerce-response
:spec ::rs/responses
:compile (fn [{:keys [coercion responses]} opts]
(if (and coercion responses)
(let [coercers (coercion/response-coercers coercion responses opts)]
{:leave
(fn [ctx]
(let [response (coercion/coerce-response coercers (:request ctx) (:response ctx))]
(assoc ctx :response response)))})))})
{:leave (fn [ctx]
(let [request (:request ctx)
response (:response ctx)]
(let [response (coercion/coerce-response coercers request response)]
(assoc ctx :response response))))})))})
(def coerce-exceptions-interceptor
(defn coerce-exceptions-interceptor
"Interceptor for handling coercion exceptions.
Expects a :coercion of type `reitit.coercion/Coercion`
and :parameters or :responses from route data, otherwise does not mount."
[]
{:name ::coerce-exceptions
:compile (fn [{:keys [coercion parameters responses]} _]
(if (and coercion (or parameters responses))

4
project.clj
View file

@ -25,7 +25,7 @@
[metosin/spec-tools "0.7.1"]
[metosin/schema-tools "0.10.3"]
[metosin/ring-swagger-ui "2.2.10"]
[metosin/muuntaja "0.6.0-alpha4"]
[metosin/muuntaja "0.6.0-alpha5"]
[metosin/jsonista "0.2.1"]
[metosin/sieppari "0.0.0-alpha4"]]
@ -62,7 +62,7 @@
[ring "1.6.3"]
[ikitommi/immutant-web "3.0.0-alpha1"]
[metosin/muuntaja "0.6.0-alpha4"]
[metosin/muuntaja "0.6.0-alpha5"]
[metosin/ring-swagger-ui "2.2.10"]
[metosin/sieppari "0.0.0-alpha4"]
[metosin/jsonista "0.2.1"]

198
test/clj/reitit/http_coercion_test.clj Normal file
View file

@ -0,0 +1,198 @@
(ns reitit.http-coercion-test
(:require [clojure.test :refer [deftest testing is]]
[schema.core :as s]
[reitit.http :as http]
[reitit.http.coercion :as rrc]
[reitit.coercion.spec :as spec]
[reitit.coercion.schema :as schema]
[muuntaja.interceptor]
[jsonista.core :as j]
[reitit.interceptor.sieppari :as sieppari])
(:import (clojure.lang ExceptionInfo)
(java.io ByteArrayInputStream)))
(defn handler [{{{:keys [a]} :query
{:keys [b]} :body
{:keys [c]} :form
{:keys [d]} :header
{:keys [e]} :path} :parameters}]
(if (= 666 a)
{:status 500
:body {:evil true}}
{:status 200
:body {:total (+ a b c d e)}}))
(def valid-request
{:uri "/api/plus/5"
:request-method :get
:query-params {"a" "1"}
:body-params {:b 2}
:form-params {:c 3}
:headers {"d" "4"}})
(def invalid-request
{:uri "/api/plus/5"
:request-method :get})
(def invalid-request2
{:uri "/api/plus/5"
:request-method :get
:query-params {"a" "1"}
:body-params {:b 2}
:form-params {:c 3}
:headers {"d" "-40"}})
(deftest spec-coercion-test
(let [create (fn [interceptors]
(http/ring-handler
(http/router
["/api"
["/plus/:e"
{:get {:parameters {:query {:a int?}
:body {:b int?}
:form {:c int?}
:header {:d int?}
:path {:e int?}}
:responses {200 {:body {:total pos-int?}}
500 {:description "fail"}}
:handler handler}}]]
{:data {:interceptors interceptors
:coercion spec/coercion}})
{:executor sieppari/executor}))]
(testing "without exception handling"
(let [app (create [(rrc/coerce-request-interceptor)
(rrc/coerce-response-interceptor)])]
(testing "all good"
(is (= {:status 200
:body {:total 15}}
(app valid-request)))
(is (= {:status 500
:body {:evil true}}
(app (assoc-in valid-request [:query-params "a"] "666")))))
(testing "invalid request"
(is (thrown-with-msg?
ExceptionInfo
#"Request coercion failed"
(app invalid-request))))
(testing "invalid response"
(is (thrown-with-msg?
ExceptionInfo
#"Response coercion failed"
(app invalid-request2))))))
(testing "with exception handling"
(let [app (create [(rrc/coerce-exceptions-interceptor)
(rrc/coerce-request-interceptor)
(rrc/coerce-response-interceptor)])]
(testing "all good"
(is (= {:status 200
:body {:total 15}}
(app valid-request))))
(testing "invalid request"
(let [{:keys [status]} (app invalid-request)]
(is (= 400 status))))
(testing "invalid response"
(let [{:keys [status]} (app invalid-request2)]
(is (= 500 status))))))))
(deftest schema-coercion-test
(let [create (fn [middleware]
(http/ring-handler
(http/router
["/api"
["/plus/:e"
{:get {:parameters {:query {:a s/Int}
:body {:b s/Int}
:form {:c s/Int}
:header {:d s/Int}
:path {:e s/Int}}
:responses {200 {:body {:total (s/constrained s/Int pos? 'positive)}}
500 {:description "fail"}}
:handler handler}}]]
{:data {:interceptors middleware
:coercion schema/coercion}})
{:executor sieppari/executor}))]
(testing "withut exception handling"
(let [app (create [(rrc/coerce-request-interceptor)
(rrc/coerce-response-interceptor)])]
(testing "all good"
(is (= {:status 200
:body {:total 15}}
(app valid-request)))
(is (= {:status 500
:body {:evil true}}
(app (assoc-in valid-request [:query-params "a"] "666")))))
(testing "invalid request"
(is (thrown-with-msg?
ExceptionInfo
#"Request coercion failed"
(app invalid-request))))
(testing "invalid response"
(is (thrown-with-msg?
ExceptionInfo
#"Response coercion failed"
(app invalid-request2))))
(testing "with exception handling"
(let [app (create [(rrc/coerce-exceptions-interceptor)
(rrc/coerce-request-interceptor)
(rrc/coerce-response-interceptor)])]
(testing "all good"
(is (= {:status 200
:body {:total 15}}
(app valid-request))))
(testing "invalid request"
(let [{:keys [status]} (app invalid-request)]
(is (= 400 status))))
(testing "invalid response"
(let [{:keys [status]} (app invalid-request2)]
(is (= 500 status))))))))))
(deftest muuntaja-test
(let [app (http/ring-handler
(http/router
["/api"
["/plus"
{:post {:parameters {:body {:int int?, :keyword keyword?}}
:responses {200 {:body {:int int?, :keyword keyword?}}}
:handler (fn [{{:keys [body]} :parameters}]
{:status 200
:body body})}}]]
{:data {:interceptors [(muuntaja.interceptor/format-interceptor)
(rrc/coerce-response-interceptor)
(rrc/coerce-request-interceptor)]
:coercion spec/coercion}})
{:executor sieppari/executor})
request (fn [content-type body]
(-> {:request-method :post
:headers {"content-type" content-type, "accept" content-type}
:uri "/api/plus"
:body body}))
data-edn {:int 1 :keyword :kikka}
data-json {:int 1 :keyword "kikka"}]
(testing "json coercion"
(let [e2e #(-> (request "application/json" (ByteArrayInputStream. (j/write-value-as-bytes %)))
(app) :body (slurp) (j/read-value (j/object-mapper {:decode-key-fn true})))]
(is (= data-json (e2e data-edn)))
(is (= data-json (e2e data-json)))))
(testing "edn coercion"
(let [e2e #(-> (request "application/edn" (pr-str %))
(app) :body slurp (read-string))]
(is (= data-edn (e2e data-edn)))
(is (thrown? ExceptionInfo (e2e data-json)))))))