actix_web/
resource.rs

1use std::{cell::RefCell, fmt, future::Future, rc::Rc};
2
3use actix_http::Extensions;
4use actix_router::{IntoPatterns, Patterns};
5use actix_service::{
6    apply, apply_fn_factory, boxed, fn_service, IntoServiceFactory, Service, ServiceFactory,
7    ServiceFactoryExt, Transform,
8};
9use futures_core::future::LocalBoxFuture;
10use futures_util::future::join_all;
11
12use crate::{
13    body::MessageBody,
14    data::Data,
15    dev::{ensure_leading_slash, AppService, ResourceDef},
16    guard::{self, Guard},
17    handler::Handler,
18    http::header,
19    route::{Route, RouteService},
20    service::{
21        BoxedHttpService, BoxedHttpServiceFactory, HttpServiceFactory, ServiceRequest,
22        ServiceResponse,
23    },
24    web, Error, FromRequest, HttpResponse, Responder,
25};
26
27/// A collection of [`Route`]s that respond to the same path pattern.
28///
29/// Resource in turn has at least one route. Route consists of an handlers objects and list of
30/// guards (objects that implement `Guard` trait). Resources and routes uses builder-like pattern
31/// for configuration. During request handling, the resource object iterates through all routes
32/// and checks guards for the specific route, if the request matches all the guards, then the route
33/// is considered matched and the route handler gets called.
34///
35/// # Examples
36/// ```
37/// use actix_web::{web, App, HttpResponse};
38///
39/// let app = App::new().service(
40///     web::resource("/")
41///         .get(|| HttpResponse::Ok())
42///         .post(|| async { "Hello World!" })
43/// );
44/// ```
45///
46/// If no matching route is found, an empty 405 response is returned which includes an
47/// [appropriate Allow header][RFC 9110 §15.5.6]. This default behavior can be overridden using
48/// [`default_service()`](Self::default_service).
49///
50/// [RFC 9110 §15.5.6]: https://www.rfc-editor.org/rfc/rfc9110.html#section-15.5.6
51pub struct Resource<T = ResourceEndpoint> {
52    endpoint: T,
53    rdef: Patterns,
54    name: Option<String>,
55    routes: Vec<Route>,
56    app_data: Option<Extensions>,
57    guards: Vec<Box<dyn Guard>>,
58    default: BoxedHttpServiceFactory,
59    factory_ref: Rc<RefCell<Option<ResourceFactory>>>,
60}
61
62impl Resource {
63    /// Constructs new resource that matches a `path` pattern.
64    pub fn new<T: IntoPatterns>(path: T) -> Resource {
65        let factory_ref = Rc::new(RefCell::new(None));
66
67        Resource {
68            routes: Vec::new(),
69            rdef: path.patterns(),
70            name: None,
71            endpoint: ResourceEndpoint::new(Rc::clone(&factory_ref)),
72            factory_ref,
73            guards: Vec::new(),
74            app_data: None,
75            default: boxed::factory(fn_service(|req: ServiceRequest| async {
76                use crate::HttpMessage as _;
77
78                let allowed = req.extensions().get::<guard::RegisteredMethods>().cloned();
79
80                if let Some(methods) = allowed {
81                    Ok(req.into_response(
82                        HttpResponse::MethodNotAllowed()
83                            .insert_header(header::Allow(methods.0))
84                            .finish(),
85                    ))
86                } else {
87                    Ok(req.into_response(HttpResponse::MethodNotAllowed()))
88                }
89            })),
90        }
91    }
92}
93
94impl<T> Resource<T>
95where
96    T: ServiceFactory<ServiceRequest, Config = (), Error = Error, InitError = ()>,
97{
98    /// Set resource name.
99    ///
100    /// Name is used for url generation.
101    pub fn name(mut self, name: &str) -> Self {
102        self.name = Some(name.to_string());
103        self
104    }
105
106    /// Add match guard to a resource.
107    ///
108    /// ```
109    /// use actix_web::{web, guard, App, HttpResponse};
110    ///
111    /// async fn index(data: web::Path<(String, String)>) -> &'static str {
112    ///     "Welcome!"
113    /// }
114    ///
115    /// let app = App::new()
116    ///     .service(
117    ///         web::resource("/app")
118    ///             .guard(guard::Header("content-type", "text/plain"))
119    ///             .route(web::get().to(index))
120    ///     )
121    ///     .service(
122    ///         web::resource("/app")
123    ///             .guard(guard::Header("content-type", "text/json"))
124    ///             .route(web::get().to(|| HttpResponse::MethodNotAllowed()))
125    ///     );
126    /// ```
127    pub fn guard<G: Guard + 'static>(mut self, guard: G) -> Self {
128        self.guards.push(Box::new(guard));
129        self
130    }
131
132    pub(crate) fn add_guards(mut self, guards: Vec<Box<dyn Guard>>) -> Self {
133        self.guards.extend(guards);
134        self
135    }
136
137    /// Register a new route.
138    ///
139    /// ```
140    /// use actix_web::{web, guard, App, HttpResponse};
141    ///
142    /// let app = App::new().service(
143    ///     web::resource("/").route(
144    ///         web::route()
145    ///             .guard(guard::Any(guard::Get()).or(guard::Put()))
146    ///             .guard(guard::Header("Content-Type", "text/plain"))
147    ///             .to(|| HttpResponse::Ok()))
148    /// );
149    /// ```
150    ///
151    /// Multiple routes could be added to a resource. Resource object uses
152    /// match guards for route selection.
153    ///
154    /// ```
155    /// use actix_web::{web, guard, App};
156    ///
157    /// let app = App::new().service(
158    ///     web::resource("/container/")
159    ///          .route(web::get().to(get_handler))
160    ///          .route(web::post().to(post_handler))
161    ///          .route(web::delete().to(delete_handler))
162    /// );
163    ///
164    /// # async fn get_handler() -> impl actix_web::Responder { actix_web::HttpResponse::Ok() }
165    /// # async fn post_handler() -> impl actix_web::Responder { actix_web::HttpResponse::Ok() }
166    /// # async fn delete_handler() -> impl actix_web::Responder { actix_web::HttpResponse::Ok() }
167    /// ```
168    pub fn route(mut self, route: Route) -> Self {
169        self.routes.push(route);
170        self
171    }
172
173    /// Add resource data.
174    ///
175    /// Data of different types from parent contexts will still be accessible. Any `Data<T>` types
176    /// set here can be extracted in handlers using the `Data<T>` extractor.
177    ///
178    /// # Examples
179    /// ```
180    /// use std::cell::Cell;
181    /// use actix_web::{web, App, HttpRequest, HttpResponse, Responder};
182    ///
183    /// struct MyData {
184    ///     count: std::cell::Cell<usize>,
185    /// }
186    ///
187    /// async fn handler(req: HttpRequest, counter: web::Data<MyData>) -> impl Responder {
188    ///     // note this cannot use the Data<T> extractor because it was not added with it
189    ///     let incr = *req.app_data::<usize>().unwrap();
190    ///     assert_eq!(incr, 3);
191    ///
192    ///     // update counter using other value from app data
193    ///     counter.count.set(counter.count.get() + incr);
194    ///
195    ///     HttpResponse::Ok().body(counter.count.get().to_string())
196    /// }
197    ///
198    /// let app = App::new().service(
199    ///     web::resource("/")
200    ///         .app_data(3usize)
201    ///         .app_data(web::Data::new(MyData { count: Default::default() }))
202    ///         .route(web::get().to(handler))
203    /// );
204    /// ```
205    #[doc(alias = "manage")]
206    pub fn app_data<U: 'static>(mut self, data: U) -> Self {
207        self.app_data
208            .get_or_insert_with(Extensions::new)
209            .insert(data);
210
211        self
212    }
213
214    /// Add resource data after wrapping in `Data<T>`.
215    ///
216    /// Deprecated in favor of [`app_data`](Self::app_data).
217    #[deprecated(since = "4.0.0", note = "Use `.app_data(Data::new(val))` instead.")]
218    pub fn data<U: 'static>(self, data: U) -> Self {
219        self.app_data(Data::new(data))
220    }
221
222    /// Register a new route and add handler. This route matches all requests.
223    ///
224    /// ```
225    /// use actix_web::{App, HttpRequest, HttpResponse, web};
226    ///
227    /// async fn index(req: HttpRequest) -> HttpResponse {
228    ///     todo!()
229    /// }
230    ///
231    /// App::new().service(web::resource("/").to(index));
232    /// ```
233    ///
234    /// This is shortcut for:
235    ///
236    /// ```
237    /// # use actix_web::*;
238    /// # async fn index(req: HttpRequest) -> HttpResponse { todo!() }
239    /// App::new().service(web::resource("/").route(web::route().to(index)));
240    /// ```
241    pub fn to<F, Args>(mut self, handler: F) -> Self
242    where
243        F: Handler<Args>,
244        Args: FromRequest + 'static,
245        F::Output: Responder + 'static,
246    {
247        self.routes.push(Route::new().to(handler));
248        self
249    }
250
251    /// Registers a resource middleware.
252    ///
253    /// `mw` is a middleware component (type), that can modify the request and response across all
254    /// routes managed by this `Resource`.
255    ///
256    /// See [`App::wrap`](crate::App::wrap) for more details.
257    #[doc(alias = "middleware")]
258    #[doc(alias = "use")] // nodejs terminology
259    pub fn wrap<M, B>(
260        self,
261        mw: M,
262    ) -> Resource<
263        impl ServiceFactory<
264            ServiceRequest,
265            Config = (),
266            Response = ServiceResponse<B>,
267            Error = Error,
268            InitError = (),
269        >,
270    >
271    where
272        M: Transform<
273                T::Service,
274                ServiceRequest,
275                Response = ServiceResponse<B>,
276                Error = Error,
277                InitError = (),
278            > + 'static,
279        B: MessageBody,
280    {
281        Resource {
282            endpoint: apply(mw, self.endpoint),
283            rdef: self.rdef,
284            name: self.name,
285            guards: self.guards,
286            routes: self.routes,
287            default: self.default,
288            app_data: self.app_data,
289            factory_ref: self.factory_ref,
290        }
291    }
292
293    /// Registers a resource function middleware.
294    ///
295    /// `mw` is a closure that runs during inbound and/or outbound processing in the request
296    /// life-cycle (request -> response), modifying request/response as necessary, across all
297    /// requests handled by the `Resource`.
298    ///
299    /// See [`App::wrap_fn`](crate::App::wrap_fn) for examples and more details.
300    #[doc(alias = "middleware")]
301    #[doc(alias = "use")] // nodejs terminology
302    pub fn wrap_fn<F, R, B>(
303        self,
304        mw: F,
305    ) -> Resource<
306        impl ServiceFactory<
307            ServiceRequest,
308            Config = (),
309            Response = ServiceResponse<B>,
310            Error = Error,
311            InitError = (),
312        >,
313    >
314    where
315        F: Fn(ServiceRequest, &T::Service) -> R + Clone + 'static,
316        R: Future<Output = Result<ServiceResponse<B>, Error>>,
317        B: MessageBody,
318    {
319        Resource {
320            endpoint: apply_fn_factory(self.endpoint, mw),
321            rdef: self.rdef,
322            name: self.name,
323            guards: self.guards,
324            routes: self.routes,
325            default: self.default,
326            app_data: self.app_data,
327            factory_ref: self.factory_ref,
328        }
329    }
330
331    /// Sets the default service to be used if no matching route is found.
332    ///
333    /// Unlike [`Scope`]s, a `Resource` does _not_ inherit its parent's default service. You can
334    /// use a [`Route`] as default service.
335    ///
336    /// If a custom default service is not registered, an empty `405 Method Not Allowed` response
337    /// with an appropriate Allow header will be sent instead.
338    ///
339    /// # Examples
340    /// ```
341    /// use actix_web::{App, HttpResponse, web};
342    ///
343    /// let resource = web::resource("/test")
344    ///     .route(web::get().to(HttpResponse::Ok))
345    ///     .default_service(web::to(|| {
346    ///         HttpResponse::BadRequest()
347    ///     }));
348    ///
349    /// App::new().service(resource);
350    /// ```
351    ///
352    /// [`Scope`]: crate::Scope
353    pub fn default_service<F, U>(mut self, f: F) -> Self
354    where
355        F: IntoServiceFactory<U, ServiceRequest>,
356        U: ServiceFactory<ServiceRequest, Config = (), Response = ServiceResponse, Error = Error>
357            + 'static,
358        U::InitError: fmt::Debug,
359    {
360        // create and configure default resource
361        self.default = boxed::factory(f.into_factory().map_init_err(|err| {
362            log::error!("Can not construct default service: {err:?}");
363        }));
364
365        self
366    }
367}
368
369macro_rules! route_shortcut {
370    ($method_fn:ident, $method_upper:literal) => {
371        #[doc = concat!(" Adds a ", $method_upper, " route.")]
372        ///
373        /// Use [`route`](Self::route) if you need to add additional guards.
374        ///
375        /// # Examples
376        ///
377        /// ```
378        /// # use actix_web::web;
379        /// web::resource("/")
380        #[doc = concat!("    .", stringify!($method_fn), "(|| async { \"Hello World!\" })")]
381        /// # ;
382        /// ```
383        pub fn $method_fn<F, Args>(self, handler: F) -> Self
384        where
385            F: Handler<Args>,
386            Args: FromRequest + 'static,
387            F::Output: Responder + 'static,
388        {
389            self.route(web::$method_fn().to(handler))
390        }
391    };
392}
393
394/// Concise routes for well-known HTTP methods.
395impl<T> Resource<T>
396where
397    T: ServiceFactory<ServiceRequest, Config = (), Error = Error, InitError = ()>,
398{
399    route_shortcut!(get, "GET");
400    route_shortcut!(post, "POST");
401    route_shortcut!(put, "PUT");
402    route_shortcut!(patch, "PATCH");
403    route_shortcut!(delete, "DELETE");
404    route_shortcut!(head, "HEAD");
405    route_shortcut!(trace, "TRACE");
406}
407
408impl<T, B> HttpServiceFactory for Resource<T>
409where
410    T: ServiceFactory<
411            ServiceRequest,
412            Config = (),
413            Response = ServiceResponse<B>,
414            Error = Error,
415            InitError = (),
416        > + 'static,
417    B: MessageBody + 'static,
418{
419    fn register(mut self, config: &mut AppService) {
420        let guards = if self.guards.is_empty() {
421            None
422        } else {
423            Some(std::mem::take(&mut self.guards))
424        };
425
426        let mut rdef = if config.is_root() || !self.rdef.is_empty() {
427            ResourceDef::new(ensure_leading_slash(self.rdef.clone()))
428        } else {
429            ResourceDef::new(self.rdef.clone())
430        };
431
432        if let Some(ref name) = self.name {
433            rdef.set_name(name);
434        }
435
436        *self.factory_ref.borrow_mut() = Some(ResourceFactory {
437            routes: self.routes,
438            default: self.default,
439        });
440
441        let resource_data = self.app_data.map(Rc::new);
442
443        // wraps endpoint service (including middleware) call and injects app data for this scope
444        let endpoint = apply_fn_factory(self.endpoint, move |mut req: ServiceRequest, srv| {
445            if let Some(ref data) = resource_data {
446                req.add_data_container(Rc::clone(data));
447            }
448
449            let fut = srv.call(req);
450
451            async { Ok(fut.await?.map_into_boxed_body()) }
452        });
453
454        config.register_service(rdef, guards, endpoint, None)
455    }
456}
457
458pub struct ResourceFactory {
459    routes: Vec<Route>,
460    default: BoxedHttpServiceFactory,
461}
462
463impl ServiceFactory<ServiceRequest> for ResourceFactory {
464    type Response = ServiceResponse;
465    type Error = Error;
466    type Config = ();
467    type Service = ResourceService;
468    type InitError = ();
469    type Future = LocalBoxFuture<'static, Result<Self::Service, Self::InitError>>;
470
471    fn new_service(&self, _: ()) -> Self::Future {
472        // construct default service factory future.
473        let default_fut = self.default.new_service(());
474
475        // construct route service factory futures
476        let factory_fut = join_all(self.routes.iter().map(|route| route.new_service(())));
477
478        Box::pin(async move {
479            let default = default_fut.await?;
480            let routes = factory_fut
481                .await
482                .into_iter()
483                .collect::<Result<Vec<_>, _>>()?;
484
485            Ok(ResourceService { routes, default })
486        })
487    }
488}
489
490pub struct ResourceService {
491    routes: Vec<RouteService>,
492    default: BoxedHttpService,
493}
494
495impl Service<ServiceRequest> for ResourceService {
496    type Response = ServiceResponse;
497    type Error = Error;
498    type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;
499
500    actix_service::always_ready!();
501
502    fn call(&self, mut req: ServiceRequest) -> Self::Future {
503        for route in &self.routes {
504            if route.check(&mut req) {
505                return route.call(req);
506            }
507        }
508
509        self.default.call(req)
510    }
511}
512
513#[doc(hidden)]
514pub struct ResourceEndpoint {
515    factory: Rc<RefCell<Option<ResourceFactory>>>,
516}
517
518impl ResourceEndpoint {
519    fn new(factory: Rc<RefCell<Option<ResourceFactory>>>) -> Self {
520        ResourceEndpoint { factory }
521    }
522}
523
524impl ServiceFactory<ServiceRequest> for ResourceEndpoint {
525    type Response = ServiceResponse;
526    type Error = Error;
527    type Config = ();
528    type Service = ResourceService;
529    type InitError = ();
530    type Future = LocalBoxFuture<'static, Result<Self::Service, Self::InitError>>;
531
532    fn new_service(&self, _: ()) -> Self::Future {
533        self.factory.borrow().as_ref().unwrap().new_service(())
534    }
535}
536
537#[cfg(test)]
538mod tests {
539    use std::time::Duration;
540
541    use actix_rt::time::sleep;
542    use actix_utils::future::ok;
543
544    use super::*;
545    use crate::{
546        http::{header::HeaderValue, Method, StatusCode},
547        middleware::DefaultHeaders,
548        test::{call_service, init_service, TestRequest},
549        App, HttpMessage,
550    };
551
552    #[test]
553    fn can_be_returned_from_fn() {
554        fn my_resource_1() -> Resource {
555            web::resource("/test1").route(web::get().to(|| async { "hello" }))
556        }
557
558        fn my_resource_2() -> Resource<
559            impl ServiceFactory<
560                ServiceRequest,
561                Config = (),
562                Response = ServiceResponse<impl MessageBody>,
563                Error = Error,
564                InitError = (),
565            >,
566        > {
567            web::resource("/test2")
568                .wrap_fn(|req, srv| {
569                    let fut = srv.call(req);
570                    async { Ok(fut.await?.map_into_right_body::<()>()) }
571                })
572                .route(web::get().to(|| async { "hello" }))
573        }
574
575        fn my_resource_3() -> impl HttpServiceFactory {
576            web::resource("/test3").route(web::get().to(|| async { "hello" }))
577        }
578
579        App::new()
580            .service(my_resource_1())
581            .service(my_resource_2())
582            .service(my_resource_3());
583    }
584
585    #[actix_rt::test]
586    async fn test_middleware() {
587        let srv = init_service(
588            App::new().service(
589                web::resource("/test")
590                    .name("test")
591                    .wrap(
592                        DefaultHeaders::new()
593                            .add((header::CONTENT_TYPE, HeaderValue::from_static("0001"))),
594                    )
595                    .route(web::get().to(HttpResponse::Ok)),
596            ),
597        )
598        .await;
599        let req = TestRequest::with_uri("/test").to_request();
600        let resp = call_service(&srv, req).await;
601        assert_eq!(resp.status(), StatusCode::OK);
602        assert_eq!(
603            resp.headers().get(header::CONTENT_TYPE).unwrap(),
604            HeaderValue::from_static("0001")
605        );
606    }
607
608    #[actix_rt::test]
609    async fn test_middleware_fn() {
610        let srv = init_service(
611            App::new().service(
612                web::resource("/test")
613                    .wrap_fn(|req, srv| {
614                        let fut = srv.call(req);
615                        async {
616                            fut.await.map(|mut res| {
617                                res.headers_mut()
618                                    .insert(header::CONTENT_TYPE, HeaderValue::from_static("0001"));
619                                res
620                            })
621                        }
622                    })
623                    .route(web::get().to(HttpResponse::Ok)),
624            ),
625        )
626        .await;
627        let req = TestRequest::with_uri("/test").to_request();
628        let resp = call_service(&srv, req).await;
629        assert_eq!(resp.status(), StatusCode::OK);
630        assert_eq!(
631            resp.headers().get(header::CONTENT_TYPE).unwrap(),
632            HeaderValue::from_static("0001")
633        );
634    }
635
636    #[actix_rt::test]
637    async fn test_to() {
638        let srv = init_service(App::new().service(web::resource("/test").to(|| async {
639            sleep(Duration::from_millis(100)).await;
640            Ok::<_, Error>(HttpResponse::Ok())
641        })))
642        .await;
643        let req = TestRequest::with_uri("/test").to_request();
644        let resp = call_service(&srv, req).await;
645        assert_eq!(resp.status(), StatusCode::OK);
646    }
647
648    #[actix_rt::test]
649    async fn test_pattern() {
650        let srv = init_service(App::new().service(
651            web::resource(["/test", "/test2"]).to(|| async { Ok::<_, Error>(HttpResponse::Ok()) }),
652        ))
653        .await;
654        let req = TestRequest::with_uri("/test").to_request();
655        let resp = call_service(&srv, req).await;
656        assert_eq!(resp.status(), StatusCode::OK);
657        let req = TestRequest::with_uri("/test2").to_request();
658        let resp = call_service(&srv, req).await;
659        assert_eq!(resp.status(), StatusCode::OK);
660    }
661
662    #[actix_rt::test]
663    async fn test_default_resource() {
664        let srv = init_service(
665            App::new()
666                .service(
667                    web::resource("/test")
668                        .route(web::get().to(HttpResponse::Ok))
669                        .route(web::delete().to(HttpResponse::Ok)),
670                )
671                .default_service(|r: ServiceRequest| {
672                    ok(r.into_response(HttpResponse::BadRequest()))
673                }),
674        )
675        .await;
676        let req = TestRequest::with_uri("/test").to_request();
677        let resp = call_service(&srv, req).await;
678        assert_eq!(resp.status(), StatusCode::OK);
679
680        let req = TestRequest::with_uri("/test")
681            .method(Method::POST)
682            .to_request();
683        let resp = call_service(&srv, req).await;
684        assert_eq!(resp.status(), StatusCode::METHOD_NOT_ALLOWED);
685        assert_eq!(
686            resp.headers().get(header::ALLOW).unwrap().as_bytes(),
687            b"GET, DELETE"
688        );
689
690        let srv = init_service(
691            App::new().service(
692                web::resource("/test")
693                    .route(web::get().to(HttpResponse::Ok))
694                    .default_service(|r: ServiceRequest| {
695                        ok(r.into_response(HttpResponse::BadRequest()))
696                    }),
697            ),
698        )
699        .await;
700
701        let req = TestRequest::with_uri("/test").to_request();
702        let resp = call_service(&srv, req).await;
703        assert_eq!(resp.status(), StatusCode::OK);
704
705        let req = TestRequest::with_uri("/test")
706            .method(Method::POST)
707            .to_request();
708        let resp = call_service(&srv, req).await;
709        assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
710    }
711
712    #[actix_rt::test]
713    async fn test_resource_guards() {
714        let srv = init_service(
715            App::new()
716                .service(
717                    web::resource("/test/{p}")
718                        .guard(guard::Get())
719                        .to(HttpResponse::Ok),
720                )
721                .service(
722                    web::resource("/test/{p}")
723                        .guard(guard::Put())
724                        .to(HttpResponse::Created),
725                )
726                .service(
727                    web::resource("/test/{p}")
728                        .guard(guard::Delete())
729                        .to(HttpResponse::NoContent),
730                ),
731        )
732        .await;
733
734        let req = TestRequest::with_uri("/test/it")
735            .method(Method::GET)
736            .to_request();
737        let resp = call_service(&srv, req).await;
738        assert_eq!(resp.status(), StatusCode::OK);
739
740        let req = TestRequest::with_uri("/test/it")
741            .method(Method::PUT)
742            .to_request();
743        let resp = call_service(&srv, req).await;
744        assert_eq!(resp.status(), StatusCode::CREATED);
745
746        let req = TestRequest::with_uri("/test/it")
747            .method(Method::DELETE)
748            .to_request();
749        let resp = call_service(&srv, req).await;
750        assert_eq!(resp.status(), StatusCode::NO_CONTENT);
751    }
752
753    // allow deprecated `{App, Resource}::data`
754    #[allow(deprecated)]
755    #[actix_rt::test]
756    async fn test_data() {
757        let srv = init_service(
758            App::new()
759                .data(1.0f64)
760                .data(1usize)
761                .app_data(web::Data::new('-'))
762                .service(
763                    web::resource("/test")
764                        .data(10usize)
765                        .app_data(web::Data::new('*'))
766                        .guard(guard::Get())
767                        .to(
768                            |data1: web::Data<usize>,
769                             data2: web::Data<char>,
770                             data3: web::Data<f64>| {
771                                assert_eq!(**data1, 10);
772                                assert_eq!(**data2, '*');
773                                let error = f64::EPSILON;
774                                assert!((**data3 - 1.0).abs() < error);
775                                HttpResponse::Ok()
776                            },
777                        ),
778                ),
779        )
780        .await;
781
782        let req = TestRequest::get().uri("/test").to_request();
783        let resp = call_service(&srv, req).await;
784        assert_eq!(resp.status(), StatusCode::OK);
785    }
786
787    // allow deprecated `{App, Resource}::data`
788    #[allow(deprecated)]
789    #[actix_rt::test]
790    async fn test_data_default_service() {
791        let srv =
792            init_service(
793                App::new().data(1usize).service(
794                    web::resource("/test")
795                        .data(10usize)
796                        .default_service(web::to(|data: web::Data<usize>| {
797                            assert_eq!(**data, 10);
798                            HttpResponse::Ok()
799                        })),
800                ),
801            )
802            .await;
803
804        let req = TestRequest::get().uri("/test").to_request();
805        let resp = call_service(&srv, req).await;
806        assert_eq!(resp.status(), StatusCode::OK);
807    }
808
809    #[actix_rt::test]
810    async fn test_middleware_app_data() {
811        let srv = init_service(
812            App::new().service(
813                web::resource("test")
814                    .app_data(1usize)
815                    .wrap_fn(|req, srv| {
816                        assert_eq!(req.app_data::<usize>(), Some(&1usize));
817                        req.extensions_mut().insert(1usize);
818                        srv.call(req)
819                    })
820                    .route(web::get().to(HttpResponse::Ok))
821                    .default_service(|req: ServiceRequest| async move {
822                        let (req, _) = req.into_parts();
823
824                        assert_eq!(req.extensions().get::<usize>(), Some(&1));
825
826                        Ok(ServiceResponse::new(
827                            req,
828                            HttpResponse::BadRequest().finish(),
829                        ))
830                    }),
831            ),
832        )
833        .await;
834
835        let req = TestRequest::get().uri("/test").to_request();
836        let resp = call_service(&srv, req).await;
837        assert_eq!(resp.status(), StatusCode::OK);
838
839        let req = TestRequest::post().uri("/test").to_request();
840        let resp = call_service(&srv, req).await;
841        assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
842    }
843
844    #[actix_rt::test]
845    async fn test_middleware_body_type() {
846        let srv = init_service(
847            App::new().service(
848                web::resource("/test")
849                    .wrap_fn(|req, srv| {
850                        let fut = srv.call(req);
851                        async { Ok(fut.await?.map_into_right_body::<()>()) }
852                    })
853                    .route(web::get().to(|| async { "hello" })),
854            ),
855        )
856        .await;
857
858        // test if `try_into_bytes()` is preserved across scope layer
859        use actix_http::body::MessageBody as _;
860        let req = TestRequest::with_uri("/test").to_request();
861        let resp = call_service(&srv, req).await;
862        let body = resp.into_body();
863        assert_eq!(body.try_into_bytes().unwrap(), b"hello".as_ref());
864    }
865}
actix_web/resource.rs

actix_web/
resource.rs
