berkus
/
actix-web
mirror of https://github.com/fafhrd91/actix-web
1
0
Fork 0
Code Issues Releases Wiki Activity

migrate to immutable service triat

This commit is contained in:
fakeshadow 2021-01-15 04:34:24 +08:00
parent 4edeb5ce47
commit 8eef8d9e10
35 changed files with 385 additions and 402 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
Cargo.toml
View File

@ -132,6 +132,12 @@ actix-multipart = { path = "actix-multipart" }
actix-files = { path = "actix-files" } actix-files = { path = "actix-files" }
awc = { path = "awc" } awc = { path = "awc" }
actix-service = { git = "https://github.com/actix/actix-net.git", branch="feat/immutable" }
actix-server = { git = "https://github.com/actix/actix-net.git", branch = "feat/immutable" }
actix-tls = { git = "https://github.com/actix/actix-net.git", branch = "feat/immutable" }
actix-utils = { git = "https://github.com/actix/actix-net.git", branch = "feat/immutable" }
actix-router = { git = "https://github.com/actix/actix-net.git", branch = "feat/immutable" }
[[bench]] [[bench]]
name = "server" name = "server"
harness = false harness = false

15
actix-files/src/files.rs
View File

@ -129,8 +129,9 @@ impl Files {
/// Set custom directory renderer /// Set custom directory renderer
pub fn files_listing_renderer<F>(mut self, f: F) -> Self pub fn files_listing_renderer<F>(mut self, f: F) -> Self
where where
for<'r, 's> F: Fn(&'r Directory, &'s HttpRequest) -> Result<ServiceResponse, io::Error> for<'r, 's> F:
+ 'static, Fn(&'r Directory, &'s HttpRequest) -> Result<ServiceResponse, io::Error>
+ 'static,
{ {
self.renderer = Rc::new(f); self.renderer = Rc::new(f);
self self
@ -204,11 +205,11 @@ impl Files {
where where
F: IntoServiceFactory<U, ServiceRequest>, F: IntoServiceFactory<U, ServiceRequest>,
U: ServiceFactory< U: ServiceFactory<
ServiceRequest, ServiceRequest,
Config = (), Config = (),
Response = ServiceResponse, Response = ServiceResponse,
Error = Error, Error = Error,
> + 'static, > + 'static,
{ {
// create and configure default resource // create and configure default resource
self.default = Rc::new(RefCell::new(Some(Rc::new(boxed::factory( self.default = Rc::new(RefCell::new(Some(Rc::new(boxed::factory(

17
actix-files/src/service.rs
View File

@ -1,9 +1,4 @@
use std::{ use std::{fmt, io, path::PathBuf, rc::Rc, task::Poll};
fmt, io,
path::PathBuf,
rc::Rc,
task::{Context, Poll},
};
use actix_service::Service; use actix_service::Service;
use actix_web::{ use actix_web::{
@ -40,10 +35,10 @@ type FilesServiceFuture = Either<
>; >;
impl FilesService { impl FilesService {
fn handle_err(&mut self, e: io::Error, req: ServiceRequest) -> FilesServiceFuture { fn handle_err(&self, e: io::Error, req: ServiceRequest) -> FilesServiceFuture {
log::debug!("Failed to handle {}: {}", req.path(), e); log::debug!("Failed to handle {}: {}", req.path(), e);
if let Some(ref mut default) = self.default { if let Some(ref default) = self.default {
Either::Right(default.call(req)) Either::Right(default.call(req))
} else { } else {
Either::Left(ok(req.error_response(e))) Either::Left(ok(req.error_response(e)))
@ -62,11 +57,9 @@ impl Service<ServiceRequest> for FilesService {
type Error = Error; type Error = Error;
type Future = FilesServiceFuture; type Future = FilesServiceFuture;
fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { actix_service::always_ready!();
Poll::Ready(Ok(()))
}
fn call(&mut self, req: ServiceRequest) -> Self::Future { fn call(&self, req: ServiceRequest) -> Self::Future {
let is_method_valid = if let Some(guard) = &self.guards { let is_method_valid = if let Some(guard) = &self.guards {
// execute user defined guards // execute user defined guards
(**guard).check(req.head()) (**guard).check(req.head())

32
actix-http/src/client/connector.rs
View File

@ -62,10 +62,10 @@ impl Connector<(), ()> {
#[allow(clippy::new_ret_no_self, clippy::let_unit_value)] #[allow(clippy::new_ret_no_self, clippy::let_unit_value)]
pub fn new() -> Connector< pub fn new() -> Connector<
impl Service< impl Service<
TcpConnect<Uri>, TcpConnect<Uri>,
Response = TcpConnection<Uri, TcpStream>, Response = TcpConnection<Uri, TcpStream>,
Error = actix_tls::connect::ConnectError, Error = actix_tls::connect::ConnectError,
> + Clone, > + Clone,
TcpStream, TcpStream,
> { > {
Connector { Connector {
@ -117,10 +117,10 @@ impl<T, U> Connector<T, U> {
where where
U1: AsyncRead + AsyncWrite + Unpin + fmt::Debug, U1: AsyncRead + AsyncWrite + Unpin + fmt::Debug,
T1: Service< T1: Service<
TcpConnect<Uri>, TcpConnect<Uri>,
Response = TcpConnection<Uri, U1>, Response = TcpConnection<Uri, U1>,
Error = actix_tls::connect::ConnectError, Error = actix_tls::connect::ConnectError,
> + Clone, > + Clone,
{ {
Connector { Connector {
connector, connector,
@ -135,10 +135,10 @@ impl<T, U> Connector<T, U>
where where
U: AsyncRead + AsyncWrite + Unpin + fmt::Debug + 'static, U: AsyncRead + AsyncWrite + Unpin + fmt::Debug + 'static,
T: Service< T: Service<
TcpConnect<Uri>, TcpConnect<Uri>,
Response = TcpConnection<Uri, U>, Response = TcpConnection<Uri, U>,
Error = actix_tls::connect::ConnectError, Error = actix_tls::connect::ConnectError,
> + Clone > + Clone
+ 'static, + 'static,
{ {
/// Connection timeout, i.e. max time to connect to remote host including dns name resolution. /// Connection timeout, i.e. max time to connect to remote host including dns name resolution.
@ -392,11 +392,11 @@ mod connect_impl {
Ready<Result<IoConnection<Io>, ConnectError>>, Ready<Result<IoConnection<Io>, ConnectError>>,
>; >;
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.tcp_pool.poll_ready(cx) self.tcp_pool.poll_ready(cx)
} }
fn call(&mut self, req: Connect) -> Self::Future { fn call(&self, req: Connect) -> Self::Future {
match req.uri.scheme_str() { match req.uri.scheme_str() {
Some("https") | Some("wss") => { Some("https") | Some("wss") => {
Either::Right(err(ConnectError::SslIsNotSupported)) Either::Right(err(ConnectError::SslIsNotSupported))
@ -460,11 +460,11 @@ mod connect_impl {
InnerConnectorResponseB<T2, Io1, Io2>, InnerConnectorResponseB<T2, Io1, Io2>,
>; >;
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.tcp_pool.poll_ready(cx) self.tcp_pool.poll_ready(cx)
} }
fn call(&mut self, req: Connect) -> Self::Future { fn call(&self, req: Connect) -> Self::Future {
match req.uri.scheme_str() { match req.uri.scheme_str() {
Some("https") | Some("wss") => Either::Right(InnerConnectorResponseB { Some("https") | Some("wss") => Either::Right(InnerConnectorResponseB {
fut: self.ssl_pool.call(req), fut: self.ssl_pool.call(req),

6
actix-http/src/client/pool.rs
View File

@ -98,12 +98,12 @@ where
type Error = ConnectError; type Error = ConnectError;
type Future = LocalBoxFuture<'static, Result<IoConnection<Io>, ConnectError>>; type Future = LocalBoxFuture<'static, Result<IoConnection<Io>, ConnectError>>;
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.0.poll_ready(cx) self.0.poll_ready(cx)
} }
fn call(&mut self, req: Connect) -> Self::Future { fn call(&self, req: Connect) -> Self::Future {
let mut connector = self.0.clone(); let connector = self.0.clone();
let inner = self.1.clone(); let inner = self.1.clone();
let fut = async move { let fut = async move {

26
actix-http/src/h1/dispatcher.rs
View File

@ -1,5 +1,4 @@
use std::{ use std::{
cell::RefCell,
collections::VecDeque, collections::VecDeque,
fmt, fmt,
future::Future, future::Future,
@ -91,7 +90,7 @@ where
U: Service<(Request, Framed<T, Codec>), Response = ()>, U: Service<(Request, Framed<T, Codec>), Response = ()>,
U::Error: fmt::Display, U::Error: fmt::Display,
{ {
flow: Rc<RefCell<HttpFlow<S, X, U>>>, flow: Rc<HttpFlow<S, X, U>>,
on_connect_data: OnConnectData, on_connect_data: OnConnectData,
flags: Flags, flags: Flags,
peer_addr: Option<net::SocketAddr>, peer_addr: Option<net::SocketAddr>,
@ -177,7 +176,7 @@ where
pub(crate) fn new( pub(crate) fn new(
stream: T, stream: T,
config: ServiceConfig, config: ServiceConfig,
services: Rc<RefCell<HttpFlow<S, X, U>>>, flow: Rc<HttpFlow<S, X, U>>,
on_connect_data: OnConnectData, on_connect_data: OnConnectData,
peer_addr: Option<net::SocketAddr>, peer_addr: Option<net::SocketAddr>,
) -> Self { ) -> Self {
@ -187,7 +186,7 @@ where
config, config,
BytesMut::with_capacity(HW_BUFFER_SIZE), BytesMut::with_capacity(HW_BUFFER_SIZE),
None, None,
services, flow,
on_connect_data, on_connect_data,
peer_addr, peer_addr,
) )
@ -200,7 +199,7 @@ where
config: ServiceConfig, config: ServiceConfig,
read_buf: BytesMut, read_buf: BytesMut,
timeout: Option<Sleep>, timeout: Option<Sleep>,
services: Rc<RefCell<HttpFlow<S, X, U>>>, flow: Rc<HttpFlow<S, X, U>>,
on_connect_data: OnConnectData, on_connect_data: OnConnectData,
peer_addr: Option<net::SocketAddr>, peer_addr: Option<net::SocketAddr>,
) -> Self { ) -> Self {
@ -230,7 +229,7 @@ where
io: Some(io), io: Some(io),
codec, codec,
read_buf, read_buf,
flow: services, flow,
on_connect_data, on_connect_data,
flags, flags,
peer_addr, peer_addr,
@ -377,7 +376,7 @@ where
Poll::Ready(Ok(req)) => { Poll::Ready(Ok(req)) => {
self.as_mut().send_continue(); self.as_mut().send_continue();
this = self.as_mut().project(); this = self.as_mut().project();
let fut = this.flow.borrow_mut().service.call(req); let fut = this.flow.service.call(req);
this.state.set(State::ServiceCall(fut)); this.state.set(State::ServiceCall(fut));
continue; continue;
} }
@ -467,12 +466,12 @@ where
if req.head().expect() { if req.head().expect() {
// set dispatcher state so the future is pinned. // set dispatcher state so the future is pinned.
let mut this = self.as_mut().project(); let mut this = self.as_mut().project();
let task = this.flow.borrow_mut().expect.call(req); let task = this.flow.expect.call(req);
this.state.set(State::ExpectCall(task)); this.state.set(State::ExpectCall(task));
} else { } else {
// the same as above. // the same as above.
let mut this = self.as_mut().project(); let mut this = self.as_mut().project();
let task = this.flow.borrow_mut().service.call(req); let task = this.flow.service.call(req);
this.state.set(State::ServiceCall(task)); this.state.set(State::ServiceCall(task));
}; };
@ -485,7 +484,7 @@ where
Poll::Ready(Ok(req)) => { Poll::Ready(Ok(req)) => {
self.as_mut().send_continue(); self.as_mut().send_continue();
let mut this = self.as_mut().project(); let mut this = self.as_mut().project();
let task = this.flow.borrow_mut().service.call(req); let task = this.flow.service.call(req);
this.state.set(State::ServiceCall(task)); this.state.set(State::ServiceCall(task));
continue; continue;
} }
@ -556,9 +555,7 @@ where
// merge on_connect_ext data into request extensions // merge on_connect_ext data into request extensions
this.on_connect_data.merge_into(&mut req); this.on_connect_data.merge_into(&mut req);
if pl == MessageType::Stream if pl == MessageType::Stream && this.flow.upgrade.is_some() {
&& this.flow.borrow().upgrade.is_some()
{
this.messages.push_back(DispatcherMessage::Upgrade(req)); this.messages.push_back(DispatcherMessage::Upgrade(req));
break; break;
} }
@ -812,9 +809,8 @@ where
let framed = Framed::from_parts(parts); let framed = Framed::from_parts(parts);
let upgrade = inner_p let upgrade = inner_p
.flow .flow
.borrow_mut()
.upgrade .upgrade
.take() .as_ref()
.unwrap() .unwrap()
.call((req, framed)); .call((req, framed));
self.as_mut() self.as_mut()

8
actix-http/src/h1/expect.rs
View File

@ -1,4 +1,4 @@
use std::task::{Context, Poll}; use std::task::Poll;
use actix_service::{Service, ServiceFactory}; use actix_service::{Service, ServiceFactory};
use futures_util::future::{ready, Ready}; use futures_util::future::{ready, Ready};
@ -26,11 +26,9 @@ impl Service<Request> for ExpectHandler {
type Error = Error; type Error = Error;
type Future = Ready<Result<Self::Response, Self::Error>>; type Future = Ready<Result<Self::Response, Self::Error>>;
fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { actix_service::always_ready!();
Poll::Ready(Ok(()))
}
fn call(&mut self, req: Request) -> Self::Future { fn call(&self, req: Request) -> Self::Future {
ready(Ok(req)) ready(Ok(req))
// TODO: add some way to trigger error // TODO: add some way to trigger error
// Err(error::ErrorExpectationFailed("test")) // Err(error::ErrorExpectationFailed("test"))

16
actix-http/src/h1/service.rs
View File

@ -1,4 +1,3 @@
use std::cell::RefCell;
use std::future::Future; use std::future::Future;
use std::marker::PhantomData; use std::marker::PhantomData;
use std::pin::Pin; use std::pin::Pin;
@ -367,7 +366,7 @@ where
X: Service<Request>, X: Service<Request>,
U: Service<(Request, Framed<T, Codec>)>, U: Service<(Request, Framed<T, Codec>)>,
{ {
flow: Rc<RefCell<HttpFlow<S, X, U>>>, flow: Rc<HttpFlow<S, X, U>>,
on_connect_ext: Option<Rc<ConnectCallback<T>>>, on_connect_ext: Option<Rc<ConnectCallback<T>>>,
cfg: ServiceConfig, cfg: ServiceConfig,
_phantom: PhantomData<B>, _phantom: PhantomData<B>,
@ -417,9 +416,9 @@ where
type Error = DispatchError; type Error = DispatchError;
type Future = Dispatcher<T, S, B, X, U>; type Future = Dispatcher<T, S, B, X, U>;
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
let mut flow = self.flow.borrow_mut(); let ready = self
let ready = flow .flow
.expect .expect
.poll_ready(cx) .poll_ready(cx)
.map_err(|e| { .map_err(|e| {
@ -429,7 +428,8 @@ where
})? })?
.is_ready(); .is_ready();
let ready = flow let ready = self
.flow
.service .service
.poll_ready(cx) .poll_ready(cx)
.map_err(|e| { .map_err(|e| {
@ -440,7 +440,7 @@ where
.is_ready() .is_ready()
&& ready; && ready;
let ready = if let Some(ref mut upg) = flow.upgrade { let ready = if let Some(ref upg) = self.flow.upgrade {
upg.poll_ready(cx) upg.poll_ready(cx)
.map_err(|e| { .map_err(|e| {
let e = e.into(); let e = e.into();
@ -460,7 +460,7 @@ where
} }
} }
fn call(&mut self, (io, addr): (T, Option<net::SocketAddr>)) -> Self::Future { fn call(&self, (io, addr): (T, Option<net::SocketAddr>)) -> Self::Future {
let on_connect_data = let on_connect_data =
OnConnectData::from_io(&io, self.on_connect_ext.as_deref()); OnConnectData::from_io(&io, self.on_connect_ext.as_deref());

8
actix-http/src/h1/upgrade.rs
View File

@ -1,4 +1,4 @@
use std::task::{Context, Poll}; use std::task::Poll;
use actix_codec::Framed; use actix_codec::Framed;
use actix_service::{Service, ServiceFactory}; use actix_service::{Service, ServiceFactory};
@ -28,11 +28,9 @@ impl<T> Service<(Request, Framed<T, Codec>)> for UpgradeHandler {
type Error = Error; type Error = Error;
type Future = Ready<Result<Self::Response, Self::Error>>; type Future = Ready<Result<Self::Response, Self::Error>>;
fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { actix_service::always_ready!();
Poll::Ready(Ok(()))
}
fn call(&mut self, _: (Request, Framed<T, Codec>)) -> Self::Future { fn call(&self, _: (Request, Framed<T, Codec>)) -> Self::Future {
ready(Ok(())) ready(Ok(()))
} }
} }

9
actix-http/src/h2/dispatcher.rs
View File

@ -1,4 +1,3 @@
use std::cell::RefCell;
use std::future::Future; use std::future::Future;
use std::marker::PhantomData; use std::marker::PhantomData;
use std::net; use std::net;
@ -37,7 +36,7 @@ where
S: Service<Request>, S: Service<Request>,
B: MessageBody, B: MessageBody,
{ {
flow: Rc<RefCell<HttpFlow<S, X, U>>>, flow: Rc<HttpFlow<S, X, U>>,
connection: Connection<T, Bytes>, connection: Connection<T, Bytes>,
on_connect_data: OnConnectData, on_connect_data: OnConnectData,
config: ServiceConfig, config: ServiceConfig,
@ -56,7 +55,7 @@ where
B: MessageBody, B: MessageBody,
{ {
pub(crate) fn new( pub(crate) fn new(
services: Rc<RefCell<HttpFlow<S, X, U>>>, flow: Rc<HttpFlow<S, X, U>>,
connection: Connection<T, Bytes>, connection: Connection<T, Bytes>,
on_connect_data: OnConnectData, on_connect_data: OnConnectData,
config: ServiceConfig, config: ServiceConfig,
@ -80,7 +79,7 @@ where
}; };
Dispatcher { Dispatcher {
flow: services, flow,
config, config,
peer_addr, peer_addr,
connection, connection,
@ -138,7 +137,7 @@ where
let svc = ServiceResponse::<S::Future, S::Response, S::Error, B> { let svc = ServiceResponse::<S::Future, S::Response, S::Error, B> {
state: ServiceResponseState::ServiceCall( state: ServiceResponseState::ServiceCall(
this.flow.borrow_mut().service.call(req), this.flow.service.call(req),
Some(res), Some(res),
), ),
config: this.config.clone(), config: this.config.clone(),

11
actix-http/src/h2/service.rs
View File

@ -1,4 +1,3 @@
use std::cell::RefCell;
use std::future::Future; use std::future::Future;
use std::marker::PhantomData; use std::marker::PhantomData;
use std::pin::Pin; use std::pin::Pin;
@ -249,7 +248,7 @@ pub struct H2ServiceHandler<T, S, B>
where where
S: Service<Request>, S: Service<Request>,
{ {
flow: Rc<RefCell<HttpFlow<S, (), ()>>>, flow: Rc<HttpFlow<S, (), ()>>,
cfg: ServiceConfig, cfg: ServiceConfig,
on_connect_ext: Option<Rc<ConnectCallback<T>>>, on_connect_ext: Option<Rc<ConnectCallback<T>>>,
_phantom: PhantomData<B>, _phantom: PhantomData<B>,
@ -290,15 +289,15 @@ where
type Error = DispatchError; type Error = DispatchError;
type Future = H2ServiceHandlerResponse<T, S, B>; type Future = H2ServiceHandlerResponse<T, S, B>;
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.flow.borrow_mut().service.poll_ready(cx).map_err(|e| { self.flow.service.poll_ready(cx).map_err(|e| {
let e = e.into(); let e = e.into();
error!("Service readiness error: {:?}", e); error!("Service readiness error: {:?}", e);
DispatchError::Service(e) DispatchError::Service(e)
}) })
} }
fn call(&mut self, (io, addr): (T, Option<net::SocketAddr>)) -> Self::Future { fn call(&self, (io, addr): (T, Option<net::SocketAddr>)) -> Self::Future {
let on_connect_data = let on_connect_data =
OnConnectData::from_io(&io, self.on_connect_ext.as_deref()); OnConnectData::from_io(&io, self.on_connect_ext.as_deref());
@ -321,7 +320,7 @@ where
{ {
Incoming(Dispatcher<T, S, B, (), ()>), Incoming(Dispatcher<T, S, B, (), ()>),
Handshake( Handshake(
Option<Rc<RefCell<HttpFlow<S, (), ()>>>>, Option<Rc<HttpFlow<S, (), ()>>>,
Option<ServiceConfig>, Option<ServiceConfig>,
Option<net::SocketAddr>, Option<net::SocketAddr>,
OnConnectData, OnConnectData,

24
actix-http/src/service.rs
View File

@ -1,4 +1,3 @@
use std::cell::RefCell;
use std::marker::PhantomData; use std::marker::PhantomData;
use std::pin::Pin; use std::pin::Pin;
use std::task::{Context, Poll}; use std::task::{Context, Poll};
@ -440,7 +439,7 @@ where
X: Service<Request>, X: Service<Request>,
U: Service<(Request, Framed<T, h1::Codec>)>, U: Service<(Request, Framed<T, h1::Codec>)>,
{ {
flow: Rc<RefCell<HttpFlow<S, X, U>>>, flow: Rc<HttpFlow<S, X, U>>,
cfg: ServiceConfig, cfg: ServiceConfig,
on_connect_ext: Option<Rc<ConnectCallback<T>>>, on_connect_ext: Option<Rc<ConnectCallback<T>>>,
_phantom: PhantomData<B>, _phantom: PhantomData<B>,
@ -454,12 +453,12 @@ pub(super) struct HttpFlow<S, X, U> {
} }
impl<S, X, U> HttpFlow<S, X, U> { impl<S, X, U> HttpFlow<S, X, U> {
pub(super) fn new(service: S, expect: X, upgrade: Option<U>) -> Rc<RefCell<Self>> { pub(super) fn new(service: S, expect: X, upgrade: Option<U>) -> Rc<Self> {
Rc::new(RefCell::new(Self { Rc::new(Self {
service, service,
expect, expect,
upgrade, upgrade,
})) })
} }
} }
@ -509,9 +508,9 @@ where
type Error = DispatchError; type Error = DispatchError;
type Future = HttpServiceHandlerResponse<T, S, B, X, U>; type Future = HttpServiceHandlerResponse<T, S, B, X, U>;
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
let mut flow = self.flow.borrow_mut(); let ready = self
let ready = flow .flow
.expect .expect
.poll_ready(cx) .poll_ready(cx)
.map_err(|e| { .map_err(|e| {
@ -521,7 +520,8 @@ where
})? })?
.is_ready(); .is_ready();
let ready = flow let ready = self
.flow
.service .service
.poll_ready(cx) .poll_ready(cx)
.map_err(|e| { .map_err(|e| {
@ -532,7 +532,7 @@ where
.is_ready() .is_ready()
&& ready; && ready;
let ready = if let Some(ref mut upg) = flow.upgrade { let ready = if let Some(ref upg) = self.flow.upgrade {
upg.poll_ready(cx) upg.poll_ready(cx)
.map_err(|e| { .map_err(|e| {
let e = e.into(); let e = e.into();
@ -553,7 +553,7 @@ where
} }
fn call( fn call(
&mut self, &self,
(io, proto, peer_addr): (T, Protocol, Option<net::SocketAddr>), (io, proto, peer_addr): (T, Protocol, Option<net::SocketAddr>),
) -> Self::Future { ) -> Self::Future {
let on_connect_data = let on_connect_data =
@ -604,7 +604,7 @@ where
Option<( Option<(
Handshake<T, Bytes>, Handshake<T, Bytes>,
ServiceConfig, ServiceConfig,
Rc<RefCell<HttpFlow<S, X, U>>>, Rc<HttpFlow<S, X, U>>,
OnConnectData, OnConnectData,
Option<net::SocketAddr>, Option<net::SocketAddr>,
)>, )>,

2
actix-http/tests/test_ws.rs
View File

@ -44,7 +44,7 @@ where
type Error = Error; type Error = Error;
type Future = Pin<Box<dyn Future<Output = Result<(), Error>>>>; type Future = Pin<Box<dyn Future<Output = Result<(), Error>>>>;
fn poll_ready(&mut self, _ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { fn poll_ready(&self, _ctx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.set_polled(); self.set_polled();
Poll::Ready(Ok(())) Poll::Ready(Ok(()))
} }

42
src/app.rs
View File

@ -271,11 +271,11 @@ where
where where
F: IntoServiceFactory<U, ServiceRequest>, F: IntoServiceFactory<U, ServiceRequest>,
U: ServiceFactory< U: ServiceFactory<
ServiceRequest, ServiceRequest,
Config = (), Config = (),
Response = ServiceResponse, Response = ServiceResponse,
Error = Error, Error = Error,
> + 'static, > + 'static,
U::InitError: fmt::Debug, U::InitError: fmt::Debug,
{ {
// create and configure default resource // create and configure default resource
@ -431,7 +431,7 @@ where
> >
where where
B1: MessageBody, B1: MessageBody,
F: FnMut(ServiceRequest, &mut T::Service) -> R + Clone, F: Fn(ServiceRequest, &T::Service) -> R + Clone,
R: Future<Output = Result<ServiceResponse<B1>, Error>>, R: Future<Output = Result<ServiceResponse<B1>, Error>>,
{ {
App { App {
@ -491,7 +491,7 @@ mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn test_default_resource() { async fn test_default_resource() {
let mut srv = init_service( let srv = init_service(
App::new().service(web::resource("/test").to(HttpResponse::Ok)), App::new().service(web::resource("/test").to(HttpResponse::Ok)),
) )
.await; .await;
@ -503,7 +503,7 @@ mod tests {
let resp = srv.call(req).await.unwrap(); let resp = srv.call(req).await.unwrap();
assert_eq!(resp.status(), StatusCode::NOT_FOUND); assert_eq!(resp.status(), StatusCode::NOT_FOUND);
let mut srv = init_service( let srv = init_service(
App::new() App::new()
.service(web::resource("/test").to(HttpResponse::Ok)) .service(web::resource("/test").to(HttpResponse::Ok))
.service( .service(
@ -536,7 +536,7 @@ mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn test_data_factory() { async fn test_data_factory() {
let mut srv = let srv =
init_service(App::new().data_factory(|| ok::<_, ()>(10usize)).service( init_service(App::new().data_factory(|| ok::<_, ()>(10usize)).service(
web::resource("/").to(|_: web::Data<usize>| HttpResponse::Ok()), web::resource("/").to(|_: web::Data<usize>| HttpResponse::Ok()),
)) ))
@ -545,7 +545,7 @@ mod tests {
let resp = srv.call(req).await.unwrap(); let resp = srv.call(req).await.unwrap();
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
let mut srv = let srv =
init_service(App::new().data_factory(|| ok::<_, ()>(10u32)).service( init_service(App::new().data_factory(|| ok::<_, ()>(10u32)).service(
web::resource("/").to(|_: web::Data<usize>| HttpResponse::Ok()), web::resource("/").to(|_: web::Data<usize>| HttpResponse::Ok()),
)) ))
@ -568,7 +568,7 @@ mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn test_extension() { async fn test_extension() {
let mut srv = init_service(App::new().app_data(10usize).service( let srv = init_service(App::new().app_data(10usize).service(
web::resource("/").to(|req: HttpRequest| { web::resource("/").to(|req: HttpRequest| {
assert_eq!(*req.app_data::<usize>().unwrap(), 10); assert_eq!(*req.app_data::<usize>().unwrap(), 10);
HttpResponse::Ok() HttpResponse::Ok()
@ -582,7 +582,7 @@ mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn test_wrap() { async fn test_wrap() {
let mut srv = init_service( let srv = init_service(
App::new() App::new()
.wrap( .wrap(
DefaultHeaders::new() DefaultHeaders::new()
@ -592,7 +592,7 @@ mod tests {
) )
.await; .await;
let req = TestRequest::with_uri("/test").to_request(); let req = TestRequest::with_uri("/test").to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
assert_eq!( assert_eq!(
resp.headers().get(header::CONTENT_TYPE).unwrap(), resp.headers().get(header::CONTENT_TYPE).unwrap(),
@ -602,7 +602,7 @@ mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn test_router_wrap() { async fn test_router_wrap() {
let mut srv = init_service( let srv = init_service(
App::new() App::new()
.route("/test", web::get().to(HttpResponse::Ok)) .route("/test", web::get().to(HttpResponse::Ok))
.wrap( .wrap(
@ -612,7 +612,7 @@ mod tests {
) )
.await; .await;
let req = TestRequest::with_uri("/test").to_request(); let req = TestRequest::with_uri("/test").to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
assert_eq!( assert_eq!(
resp.headers().get(header::CONTENT_TYPE).unwrap(), resp.headers().get(header::CONTENT_TYPE).unwrap(),
@ -622,7 +622,7 @@ mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn test_wrap_fn() { async fn test_wrap_fn() {
let mut srv = init_service( let srv = init_service(
App::new() App::new()
.wrap_fn(|req, srv| { .wrap_fn(|req, srv| {
let fut = srv.call(req); let fut = srv.call(req);
@ -639,7 +639,7 @@ mod tests {
) )
.await; .await;
let req = TestRequest::with_uri("/test").to_request(); let req = TestRequest::with_uri("/test").to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
assert_eq!( assert_eq!(
resp.headers().get(header::CONTENT_TYPE).unwrap(), resp.headers().get(header::CONTENT_TYPE).unwrap(),
@ -649,7 +649,7 @@ mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn test_router_wrap_fn() { async fn test_router_wrap_fn() {
let mut srv = init_service( let srv = init_service(
App::new() App::new()
.route("/test", web::get().to(HttpResponse::Ok)) .route("/test", web::get().to(HttpResponse::Ok))
.wrap_fn(|req, srv| { .wrap_fn(|req, srv| {
@ -666,7 +666,7 @@ mod tests {
) )
.await; .await;
let req = TestRequest::with_uri("/test").to_request(); let req = TestRequest::with_uri("/test").to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
assert_eq!( assert_eq!(
resp.headers().get(header::CONTENT_TYPE).unwrap(), resp.headers().get(header::CONTENT_TYPE).unwrap(),
@ -676,7 +676,7 @@ mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn test_external_resource() { async fn test_external_resource() {
let mut srv = init_service( let srv = init_service(
App::new() App::new()
.external_resource("youtube", "https://youtube.com/watch/{video_id}") .external_resource("youtube", "https://youtube.com/watch/{video_id}")
.route( .route(
@ -690,7 +690,7 @@ mod tests {
) )
.await; .await;
let req = TestRequest::with_uri("/test").to_request(); let req = TestRequest::with_uri("/test").to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
let body = read_body(resp).await; let body = read_body(resp).await;
assert_eq!(body, Bytes::from_static(b"https://youtube.com/watch/12345")); assert_eq!(body, Bytes::from_static(b"https://youtube.com/watch/12345"));

6
src/app_service.rs
View File

@ -203,7 +203,7 @@ where
actix_service::forward_ready!(service); actix_service::forward_ready!(service);
fn call(&mut self, req: Request) -> Self::Future { fn call(&self, req: Request) -> Self::Future {
let (head, payload) = req.into_parts(); let (head, payload) = req.into_parts();
let req = if let Some(mut req) = self.app_state.pool().pop() { let req = if let Some(mut req) = self.app_state.pool().pop() {
@ -294,7 +294,7 @@ impl Service<ServiceRequest> for AppRouting {
actix_service::always_ready!(); actix_service::always_ready!();
fn call(&mut self, mut req: ServiceRequest) -> Self::Future { fn call(&self, mut req: ServiceRequest) -> Self::Future {
let res = self.router.recognize_mut_checked(&mut req, |req, guards| { let res = self.router.recognize_mut_checked(&mut req, |req, guards| {
if let Some(ref guards) = guards { if let Some(ref guards) = guards {
for f in guards { for f in guards {
@ -361,7 +361,7 @@ mod tests {
let data = Arc::new(AtomicBool::new(false)); let data = Arc::new(AtomicBool::new(false));
{ {
let mut app = init_service( let app = init_service(
App::new() App::new()
.data(DropData(data.clone())) .data(DropData(data.clone()))
.service(web::resource("/test").to(HttpResponse::Ok)), .service(web::resource("/test").to(HttpResponse::Ok)),

28
src/config.rs
View File

@ -107,12 +107,12 @@ impl AppService {
) where ) where
F: IntoServiceFactory<S, ServiceRequest>, F: IntoServiceFactory<S, ServiceRequest>,
S: ServiceFactory< S: ServiceFactory<
ServiceRequest, ServiceRequest,
Config = (), Config = (),
Response = ServiceResponse, Response = ServiceResponse,
Error = Error, Error = Error,
InitError = (), InitError = (),
> + 'static, > + 'static,
{ {
self.services.push(( self.services.push((
rdef, rdef,
@ -265,7 +265,7 @@ mod tests {
cfg.app_data(15u8); cfg.app_data(15u8);
}; };
let mut srv = init_service(App::new().configure(cfg).service( let srv = init_service(App::new().configure(cfg).service(
web::resource("/").to(|_: web::Data<usize>, req: HttpRequest| { web::resource("/").to(|_: web::Data<usize>, req: HttpRequest| {
assert_eq!(*req.app_data::<u8>().unwrap(), 15u8); assert_eq!(*req.app_data::<u8>().unwrap(), 15u8);
HttpResponse::Ok() HttpResponse::Ok()
@ -288,7 +288,7 @@ mod tests {
// }); // });
// }; // };
// let mut srv = // let srv =
// init_service(App::new().configure(cfg).service( // init_service(App::new().configure(cfg).service(
// web::resource("/").to(|_: web::Data<usize>| HttpResponse::Ok()), // web::resource("/").to(|_: web::Data<usize>| HttpResponse::Ok()),
// )); // ));
@ -299,7 +299,7 @@ mod tests {
// let cfg2 = |cfg: &mut ServiceConfig| { // let cfg2 = |cfg: &mut ServiceConfig| {
// cfg.data_factory(|| Ok::<_, ()>(10u32)); // cfg.data_factory(|| Ok::<_, ()>(10u32));
// }; // };
// let mut srv = init_service( // let srv = init_service(
// App::new() // App::new()
// .service(web::resource("/").to(|_: web::Data<usize>| HttpResponse::Ok())) // .service(web::resource("/").to(|_: web::Data<usize>| HttpResponse::Ok()))
// .configure(cfg2), // .configure(cfg2),
@ -311,7 +311,7 @@ mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn test_external_resource() { async fn test_external_resource() {
let mut srv = init_service( let srv = init_service(
App::new() App::new()
.configure(|cfg| { .configure(|cfg| {
cfg.external_resource( cfg.external_resource(
@ -330,7 +330,7 @@ mod tests {
) )
.await; .await;
let req = TestRequest::with_uri("/test").to_request(); let req = TestRequest::with_uri("/test").to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
let body = read_body(resp).await; let body = read_body(resp).await;
assert_eq!(body, Bytes::from_static(b"https://youtube.com/watch/12345")); assert_eq!(body, Bytes::from_static(b"https://youtube.com/watch/12345"));
@ -338,7 +338,7 @@ mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn test_service() { async fn test_service() {
let mut srv = init_service(App::new().configure(|cfg| { let srv = init_service(App::new().configure(|cfg| {
cfg.service( cfg.service(
web::resource("/test").route(web::get().to(HttpResponse::Created)), web::resource("/test").route(web::get().to(HttpResponse::Created)),
) )
@ -349,13 +349,13 @@ mod tests {
let req = TestRequest::with_uri("/test") let req = TestRequest::with_uri("/test")
.method(Method::GET) .method(Method::GET)
.to_request(); .to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::CREATED); assert_eq!(resp.status(), StatusCode::CREATED);
let req = TestRequest::with_uri("/index.html") let req = TestRequest::with_uri("/index.html")
.method(Method::GET) .method(Method::GET)
.to_request(); .to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
} }
} }

14
src/data.rs
View File

@ -147,7 +147,7 @@ mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn test_data_extractor() { async fn test_data_extractor() {
let mut srv = init_service(App::new().data("TEST".to_string()).service( let srv = init_service(App::new().data("TEST".to_string()).service(
web::resource("/").to(|data: web::Data<String>| { web::resource("/").to(|data: web::Data<String>| {
assert_eq!(data.to_lowercase(), "test"); assert_eq!(data.to_lowercase(), "test");
HttpResponse::Ok() HttpResponse::Ok()
@ -159,7 +159,7 @@ mod tests {
let resp = srv.call(req).await.unwrap(); let resp = srv.call(req).await.unwrap();
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
let mut srv = let srv =
init_service(App::new().data(10u32).service( init_service(App::new().data(10u32).service(
web::resource("/").to(|_: web::Data<usize>| HttpResponse::Ok()), web::resource("/").to(|_: web::Data<usize>| HttpResponse::Ok()),
)) ))
@ -171,7 +171,7 @@ mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn test_app_data_extractor() { async fn test_app_data_extractor() {
let mut srv = let srv =
init_service(App::new().app_data(Data::new(10usize)).service( init_service(App::new().app_data(Data::new(10usize)).service(
web::resource("/").to(|_: web::Data<usize>| HttpResponse::Ok()), web::resource("/").to(|_: web::Data<usize>| HttpResponse::Ok()),
)) ))
@ -181,7 +181,7 @@ mod tests {
let resp = srv.call(req).await.unwrap(); let resp = srv.call(req).await.unwrap();
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
let mut srv = let srv =
init_service(App::new().app_data(Data::new(10u32)).service( init_service(App::new().app_data(Data::new(10u32)).service(
web::resource("/").to(|_: web::Data<usize>| HttpResponse::Ok()), web::resource("/").to(|_: web::Data<usize>| HttpResponse::Ok()),
)) ))
@ -193,7 +193,7 @@ mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn test_route_data_extractor() { async fn test_route_data_extractor() {
let mut srv = init_service( let srv = init_service(
App::new().service( App::new().service(
web::resource("/") web::resource("/")
.data(10usize) .data(10usize)
@ -207,7 +207,7 @@ mod tests {
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
// different type // different type
let mut srv = init_service( let srv = init_service(
App::new().service( App::new().service(
web::resource("/") web::resource("/")
.data(10u32) .data(10u32)
@ -222,7 +222,7 @@ mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn test_override_data() { async fn test_override_data() {
let mut srv = init_service(App::new().data(1usize).service( let srv = init_service(App::new().data(1usize).service(
web::resource("/").data(10usize).route(web::get().to( web::resource("/").data(10usize).route(web::get().to(
|data: web::Data<usize>| { |data: web::Data<usize>| {
assert_eq!(**data, 10); assert_eq!(**data, 10);

4
src/handler.rs
View File

@ -113,11 +113,11 @@ where
type Error = Error; type Error = Error;
type Future = HandlerServiceFuture<F, T, R>; type Future = HandlerServiceFuture<F, T, R>;
fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { fn poll_ready(&self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
Poll::Ready(Ok(())) Poll::Ready(Ok(()))
} }
fn call(&mut self, req: ServiceRequest) -> Self::Future { fn call(&self, req: ServiceRequest) -> Self::Future {
let (req, mut payload) = req.into_parts(); let (req, mut payload) = req.into_parts();
let fut = T::from_request(&req, &mut payload); let fut = T::from_request(&req, &mut payload);
HandlerServiceFuture::Extract(fut, Some(req), self.hnd.clone()) HandlerServiceFuture::Extract(fut, Some(req), self.hnd.clone())

16
src/middleware/compat.rs
View File

@ -80,11 +80,11 @@ where
type Error = Error; type Error = Error;
type Future = CompatMiddlewareFuture<S::Future>; type Future = CompatMiddlewareFuture<S::Future>;
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.service.poll_ready(cx).map_err(From::from) self.service.poll_ready(cx).map_err(From::from)
} }
fn call(&mut self, req: Req) -> Self::Future { fn call(&self, req: Req) -> Self::Future {
let fut = self.service.call(req); let fut = self.service.call(req);
CompatMiddlewareFuture { fut } CompatMiddlewareFuture { fut }
} }
@ -139,7 +139,7 @@ mod tests {
let logger = Logger::default(); let logger = Logger::default();
let compress = Compress::default(); let compress = Compress::default();
let mut srv = init_service( let srv = init_service(
App::new().service( App::new().service(
web::scope("app") web::scope("app")
.wrap(Compat::new(logger)) .wrap(Compat::new(logger))
@ -152,7 +152,7 @@ mod tests {
.await; .await;
let req = TestRequest::with_uri("/app/test").to_request(); let req = TestRequest::with_uri("/app/test").to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
} }
@ -161,7 +161,7 @@ mod tests {
let logger = Logger::default(); let logger = Logger::default();
let compress = Compress::default(); let compress = Compress::default();
let mut srv = init_service( let srv = init_service(
App::new().service( App::new().service(
web::resource("app/test") web::resource("app/test")
.wrap(Compat::new(logger)) .wrap(Compat::new(logger))
@ -172,7 +172,7 @@ mod tests {
.await; .await;
let req = TestRequest::with_uri("/app/test").to_request(); let req = TestRequest::with_uri("/app/test").to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
} }
@ -186,11 +186,11 @@ mod tests {
let logger = Logger::default(); let logger = Logger::default();
let mut mw = Condition::new(true, Compat::new(logger)) let mw = Condition::new(true, Compat::new(logger))
.new_transform(srv.into_service()) .new_transform(srv.into_service())
.await .await
.unwrap(); .unwrap();
let resp = call_service(&mut mw, TestRequest::default().to_srv_request()).await; let resp = call_service(&mw, TestRequest::default().to_srv_request()).await;
assert_eq!(resp.status(), StatusCode::INTERNAL_SERVER_ERROR); assert_eq!(resp.status(), StatusCode::INTERNAL_SERVER_ERROR);
} }
} }

2
src/middleware/compress.rs
View File

@ -89,7 +89,7 @@ where
actix_service::forward_ready!(service); actix_service::forward_ready!(service);
#[allow(clippy::borrow_interior_mutable_const)] #[allow(clippy::borrow_interior_mutable_const)]
fn call(&mut self, req: ServiceRequest) -> Self::Future { fn call(&self, req: ServiceRequest) -> Self::Future {
// negotiate content-encoding // negotiate content-encoding
let encoding = if let Some(val) = req.headers().get(&ACCEPT_ENCODING) { let encoding = if let Some(val) = req.headers().get(&ACCEPT_ENCODING) {
if let Ok(enc) = val.to_str() { if let Ok(enc) = val.to_str() {

12
src/middleware/condition.rs
View File

@ -76,14 +76,14 @@ where
type Error = E::Error; type Error = E::Error;
type Future = Either<E::Future, D::Future>; type Future = Either<E::Future, D::Future>;
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
match self { match self {
ConditionMiddleware::Enable(service) => service.poll_ready(cx), ConditionMiddleware::Enable(service) => service.poll_ready(cx),
ConditionMiddleware::Disable(service) => service.poll_ready(cx), ConditionMiddleware::Disable(service) => service.poll_ready(cx),
} }
} }
fn call(&mut self, req: Req) -> Self::Future { fn call(&self, req: Req) -> Self::Future {
match self { match self {
ConditionMiddleware::Enable(service) => Either::Left(service.call(req)), ConditionMiddleware::Enable(service) => Either::Left(service.call(req)),
ConditionMiddleware::Disable(service) => Either::Right(service.call(req)), ConditionMiddleware::Disable(service) => Either::Right(service.call(req)),
@ -123,12 +123,12 @@ mod tests {
let mw = let mw =
ErrorHandlers::new().handler(StatusCode::INTERNAL_SERVER_ERROR, render_500); ErrorHandlers::new().handler(StatusCode::INTERNAL_SERVER_ERROR, render_500);
let mut mw = Condition::new(true, mw) let mw = Condition::new(true, mw)
.new_transform(srv.into_service()) .new_transform(srv.into_service())
.await .await
.unwrap(); .unwrap();
let resp = let resp =
test::call_service(&mut mw, TestRequest::default().to_srv_request()).await; test::call_service(&mw, TestRequest::default().to_srv_request()).await;
assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(), "0001"); assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(), "0001");
} }
@ -141,13 +141,13 @@ mod tests {
let mw = let mw =
ErrorHandlers::new().handler(StatusCode::INTERNAL_SERVER_ERROR, render_500); ErrorHandlers::new().handler(StatusCode::INTERNAL_SERVER_ERROR, render_500);
let mut mw = Condition::new(false, mw) let mw = Condition::new(false, mw)
.new_transform(srv.into_service()) .new_transform(srv.into_service())
.await .await
.unwrap(); .unwrap();
let resp = let resp =
test::call_service(&mut mw, TestRequest::default().to_srv_request()).await; test::call_service(&mw, TestRequest::default().to_srv_request()).await;
assert_eq!(resp.headers().get(CONTENT_TYPE), None); assert_eq!(resp.headers().get(CONTENT_TYPE), None);
} }
} }

8
src/middleware/default_headers.rs
View File

@ -143,7 +143,7 @@ where
actix_service::forward_ready!(service); actix_service::forward_ready!(service);
fn call(&mut self, req: ServiceRequest) -> Self::Future { fn call(&self, req: ServiceRequest) -> Self::Future {
let inner = self.inner.clone(); let inner = self.inner.clone();
let fut = self.service.call(req); let fut = self.service.call(req);
@ -200,7 +200,7 @@ mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn test_default_headers() { async fn test_default_headers() {
let mut mw = DefaultHeaders::new() let mw = DefaultHeaders::new()
.header(CONTENT_TYPE, "0001") .header(CONTENT_TYPE, "0001")
.new_transform(ok_service()) .new_transform(ok_service())
.await .await
@ -215,7 +215,7 @@ mod tests {
ok(req ok(req
.into_response(HttpResponse::Ok().header(CONTENT_TYPE, "0002").finish())) .into_response(HttpResponse::Ok().header(CONTENT_TYPE, "0002").finish()))
}; };
let mut mw = DefaultHeaders::new() let mw = DefaultHeaders::new()
.header(CONTENT_TYPE, "0001") .header(CONTENT_TYPE, "0001")
.new_transform(srv.into_service()) .new_transform(srv.into_service())
.await .await
@ -228,7 +228,7 @@ mod tests {
async fn test_content_type() { async fn test_content_type() {
let srv = let srv =
|req: ServiceRequest| ok(req.into_response(HttpResponse::Ok().finish())); |req: ServiceRequest| ok(req.into_response(HttpResponse::Ok().finish()));
let mut mw = DefaultHeaders::new() let mw = DefaultHeaders::new()
.add_content_type() .add_content_type()
.new_transform(srv.into_service()) .new_transform(srv.into_service())
.await .await

10
src/middleware/err_handlers.rs
View File

@ -123,7 +123,7 @@ where
actix_service::forward_ready!(service); actix_service::forward_ready!(service);
fn call(&mut self, req: ServiceRequest) -> Self::Future { fn call(&self, req: ServiceRequest) -> Self::Future {
let handlers = self.handlers.clone(); let handlers = self.handlers.clone();
let fut = self.service.call(req); let fut = self.service.call(req);
ErrorHandlersFuture::ServiceFuture { fut, handlers } ErrorHandlersFuture::ServiceFuture { fut, handlers }
@ -196,14 +196,14 @@ mod tests {
ok(req.into_response(HttpResponse::InternalServerError().finish())) ok(req.into_response(HttpResponse::InternalServerError().finish()))
}; };
let mut mw = ErrorHandlers::new() let mw = ErrorHandlers::new()
.handler(StatusCode::INTERNAL_SERVER_ERROR, render_500) .handler(StatusCode::INTERNAL_SERVER_ERROR, render_500)
.new_transform(srv.into_service()) .new_transform(srv.into_service())
.await .await
.unwrap(); .unwrap();
let resp = let resp =
test::call_service(&mut mw, TestRequest::default().to_srv_request()).await; test::call_service(&mw, TestRequest::default().to_srv_request()).await;
assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(), "0001"); assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(), "0001");
} }
@ -223,14 +223,14 @@ mod tests {
ok(req.into_response(HttpResponse::InternalServerError().finish())) ok(req.into_response(HttpResponse::InternalServerError().finish()))
}; };
let mut mw = ErrorHandlers::new() let mw = ErrorHandlers::new()
.handler(StatusCode::INTERNAL_SERVER_ERROR, render_500_async) .handler(StatusCode::INTERNAL_SERVER_ERROR, render_500_async)
.new_transform(srv.into_service()) .new_transform(srv.into_service())
.await .await
.unwrap(); .unwrap();
let resp = let resp =
test::call_service(&mut mw, TestRequest::default().to_srv_request()).await; test::call_service(&mw, TestRequest::default().to_srv_request()).await;
assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(), "0001"); assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(), "0001");
} }
} }

8
src/middleware/logger.rs
View File

@ -219,7 +219,7 @@ where
actix_service::forward_ready!(service); actix_service::forward_ready!(service);
fn call(&mut self, req: ServiceRequest) -> Self::Future { fn call(&self, req: ServiceRequest) -> Self::Future {
if self.inner.exclude.contains(req.path()) if self.inner.exclude.contains(req.path())
|| self.inner.exclude_regex.is_match(req.path()) || self.inner.exclude_regex.is_match(req.path())
{ {
@ -609,7 +609,7 @@ mod tests {
}; };
let logger = Logger::new("%% %{User-Agent}i %{X-Test}o %{HOME}e %D test"); let logger = Logger::new("%% %{User-Agent}i %{X-Test}o %{HOME}e %D test");
let mut srv = logger.new_transform(srv.into_service()).await.unwrap(); let srv = logger.new_transform(srv.into_service()).await.unwrap();
let req = TestRequest::with_header( let req = TestRequest::with_header(
header::USER_AGENT, header::USER_AGENT,
@ -631,7 +631,7 @@ mod tests {
let logger = Logger::new("%% %{User-Agent}i %{X-Test}o %{HOME}e %D test") let logger = Logger::new("%% %{User-Agent}i %{X-Test}o %{HOME}e %D test")
.exclude_regex("\\w"); .exclude_regex("\\w");
let mut srv = logger.new_transform(srv.into_service()).await.unwrap(); let srv = logger.new_transform(srv.into_service()).await.unwrap();
let req = TestRequest::with_header( let req = TestRequest::with_header(
header::USER_AGENT, header::USER_AGENT,
@ -801,7 +801,7 @@ mod tests {
captured.to_owned() captured.to_owned()
}); });
let mut srv = logger.new_transform(test::ok_service()).await.unwrap(); let srv = logger.new_transform(test::ok_service()).await.unwrap();
let req = TestRequest::default().to_srv_request(); let req = TestRequest::default().to_srv_request();
srv.call(req).await.unwrap(); srv.call(req).await.unwrap();

54
src/middleware/normalize.rs
View File

@ -66,22 +66,22 @@ impl Default for TrailingSlash {
/// use actix_web::http::StatusCode; /// use actix_web::http::StatusCode;
/// use actix_web::test::{call_service, init_service, TestRequest}; /// use actix_web::test::{call_service, init_service, TestRequest};
/// ///
/// let mut app = init_service(app).await; /// let app = init_service(app).await;
/// ///
/// let req = TestRequest::with_uri("/test").to_request(); /// let req = TestRequest::with_uri("/test").to_request();
/// let res = call_service(&mut app, req).await; /// let res = call_service(&app, req).await;
/// assert_eq!(res.status(), StatusCode::OK); /// assert_eq!(res.status(), StatusCode::OK);
/// ///
/// let req = TestRequest::with_uri("/test/").to_request(); /// let req = TestRequest::with_uri("/test/").to_request();
/// let res = call_service(&mut app, req).await; /// let res = call_service(&app, req).await;
/// assert_eq!(res.status(), StatusCode::OK); /// assert_eq!(res.status(), StatusCode::OK);
/// ///
/// let req = TestRequest::with_uri("/unmatchable").to_request(); /// let req = TestRequest::with_uri("/unmatchable").to_request();
/// let res = call_service(&mut app, req).await; /// let res = call_service(&app, req).await;
/// assert_eq!(res.status(), StatusCode::NOT_FOUND); /// assert_eq!(res.status(), StatusCode::NOT_FOUND);
/// ///
/// let req = TestRequest::with_uri("/unmatchable/").to_request(); /// let req = TestRequest::with_uri("/unmatchable/").to_request();
/// let res = call_service(&mut app, req).await; /// let res = call_service(&app, req).await;
/// assert_eq!(res.status(), StatusCode::NOT_FOUND); /// assert_eq!(res.status(), StatusCode::NOT_FOUND);
/// # }) /// # })
/// ``` /// ```
@ -132,7 +132,7 @@ where
actix_service::forward_ready!(service); actix_service::forward_ready!(service);
fn call(&mut self, mut req: ServiceRequest) -> Self::Future { fn call(&self, mut req: ServiceRequest) -> Self::Future {
let head = req.head_mut(); let head = req.head_mut();
let original_path = head.uri.path(); let original_path = head.uri.path();
@ -195,7 +195,7 @@ mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn test_wrap() { async fn test_wrap() {
let mut app = init_service( let app = init_service(
App::new() App::new()
.wrap(NormalizePath::default()) .wrap(NormalizePath::default())
.service(web::resource("/").to(HttpResponse::Ok)) .service(web::resource("/").to(HttpResponse::Ok))
@ -204,37 +204,37 @@ mod tests {
.await; .await;
let req = TestRequest::with_uri("/").to_request(); let req = TestRequest::with_uri("/").to_request();
let res = call_service(&mut app, req).await; let res = call_service(&app, req).await;
assert!(res.status().is_success()); assert!(res.status().is_success());
let req = TestRequest::with_uri("/?query=test").to_request(); let req = TestRequest::with_uri("/?query=test").to_request();
let res = call_service(&mut app, req).await; let res = call_service(&app, req).await;
assert!(res.status().is_success()); assert!(res.status().is_success());
let req = TestRequest::with_uri("///").to_request(); let req = TestRequest::with_uri("///").to_request();
let res = call_service(&mut app, req).await; let res = call_service(&app, req).await;
assert!(res.status().is_success()); assert!(res.status().is_success());
let req = TestRequest::with_uri("/v1//something////").to_request(); let req = TestRequest::with_uri("/v1//something////").to_request();
let res = call_service(&mut app, req).await; let res = call_service(&app, req).await;
assert!(res.status().is_success()); assert!(res.status().is_success());
let req2 = TestRequest::with_uri("//v1/something").to_request(); let req2 = TestRequest::with_uri("//v1/something").to_request();
let res2 = call_service(&mut app, req2).await; let res2 = call_service(&app, req2).await;
assert!(res2.status().is_success()); assert!(res2.status().is_success());
let req3 = TestRequest::with_uri("//v1//////something").to_request(); let req3 = TestRequest::with_uri("//v1//////something").to_request();
let res3 = call_service(&mut app, req3).await; let res3 = call_service(&app, req3).await;
assert!(res3.status().is_success()); assert!(res3.status().is_success());
let req4 = TestRequest::with_uri("/v1//something").to_request(); let req4 = TestRequest::with_uri("/v1//something").to_request();
let res4 = call_service(&mut app, req4).await; let res4 = call_service(&app, req4).await;
assert!(res4.status().is_success()); assert!(res4.status().is_success());
} }
#[actix_rt::test] #[actix_rt::test]
async fn trim_trailing_slashes() { async fn trim_trailing_slashes() {
let mut app = init_service( let app = init_service(
App::new() App::new()
.wrap(NormalizePath(TrailingSlash::Trim)) .wrap(NormalizePath(TrailingSlash::Trim))
.service(web::resource("/").to(HttpResponse::Ok)) .service(web::resource("/").to(HttpResponse::Ok))
@ -244,37 +244,37 @@ mod tests {
// root paths should still work // root paths should still work
let req = TestRequest::with_uri("/").to_request(); let req = TestRequest::with_uri("/").to_request();
let res = call_service(&mut app, req).await; let res = call_service(&app, req).await;
assert!(res.status().is_success()); assert!(res.status().is_success());
let req = TestRequest::with_uri("/?query=test").to_request(); let req = TestRequest::with_uri("/?query=test").to_request();
let res = call_service(&mut app, req).await; let res = call_service(&app, req).await;
assert!(res.status().is_success()); assert!(res.status().is_success());
let req = TestRequest::with_uri("///").to_request(); let req = TestRequest::with_uri("///").to_request();
let res = call_service(&mut app, req).await; let res = call_service(&app, req).await;
assert!(res.status().is_success()); assert!(res.status().is_success());
let req = TestRequest::with_uri("/v1/something////").to_request(); let req = TestRequest::with_uri("/v1/something////").to_request();
let res = call_service(&mut app, req).await; let res = call_service(&app, req).await;
assert!(res.status().is_success()); assert!(res.status().is_success());
let req2 = TestRequest::with_uri("/v1/something/").to_request(); let req2 = TestRequest::with_uri("/v1/something/").to_request();
let res2 = call_service(&mut app, req2).await; let res2 = call_service(&app, req2).await;
assert!(res2.status().is_success()); assert!(res2.status().is_success());
let req3 = TestRequest::with_uri("//v1//something//").to_request(); let req3 = TestRequest::with_uri("//v1//something//").to_request();
let res3 = call_service(&mut app, req3).await; let res3 = call_service(&app, req3).await;
assert!(res3.status().is_success()); assert!(res3.status().is_success());
let req4 = TestRequest::with_uri("//v1//something").to_request(); let req4 = TestRequest::with_uri("//v1//something").to_request();
let res4 = call_service(&mut app, req4).await; let res4 = call_service(&app, req4).await;
assert!(res4.status().is_success()); assert!(res4.status().is_success());
} }
#[actix_rt::test] #[actix_rt::test]
async fn keep_trailing_slash_unchanged() { async fn keep_trailing_slash_unchanged() {
let mut app = init_service( let app = init_service(
App::new() App::new()
.wrap(NormalizePath(TrailingSlash::MergeOnly)) .wrap(NormalizePath(TrailingSlash::MergeOnly))
.service(web::resource("/").to(HttpResponse::Ok)) .service(web::resource("/").to(HttpResponse::Ok))
@ -299,7 +299,7 @@ mod tests {
for (path, success) in tests { for (path, success) in tests {
let req = TestRequest::with_uri(path).to_request(); let req = TestRequest::with_uri(path).to_request();
let res = call_service(&mut app, req).await; let res = call_service(&app, req).await;
assert_eq!(res.status().is_success(), success); assert_eq!(res.status().is_success(), success);
} }
} }
@ -311,7 +311,7 @@ mod tests {
ready(Ok(req.into_response(HttpResponse::Ok().finish()))) ready(Ok(req.into_response(HttpResponse::Ok().finish())))
}; };
let mut normalize = NormalizePath::default() let normalize = NormalizePath::default()
.new_transform(srv.into_service()) .new_transform(srv.into_service())
.await .await
.unwrap(); .unwrap();
@ -342,7 +342,7 @@ mod tests {
ready(Ok(req.into_response(HttpResponse::Ok().finish()))) ready(Ok(req.into_response(HttpResponse::Ok().finish())))
}; };
let mut normalize = NormalizePath::default() let normalize = NormalizePath::default()
.new_transform(srv.into_service()) .new_transform(srv.into_service())
.await .await
.unwrap(); .unwrap();
@ -359,7 +359,7 @@ mod tests {
ready(Ok(req.into_response(HttpResponse::Ok().finish()))) ready(Ok(req.into_response(HttpResponse::Ok().finish())))
}; };
let mut normalize = NormalizePath::default() let normalize = NormalizePath::default()
.new_transform(srv.into_service()) .new_transform(srv.into_service())
.await .await
.unwrap(); .unwrap();

34
src/request.rs
View File

@ -554,7 +554,7 @@ mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn test_drop_http_request_pool() { async fn test_drop_http_request_pool() {
let mut srv = init_service(App::new().service(web::resource("/").to( let srv = init_service(App::new().service(web::resource("/").to(
|req: HttpRequest| { |req: HttpRequest| {
HttpResponse::Ok() HttpResponse::Ok()
.set_header("pool_cap", req.app_state().pool().cap) .set_header("pool_cap", req.app_state().pool().cap)
@ -564,7 +564,7 @@ mod tests {
.await; .await;
let req = TestRequest::default().to_request(); let req = TestRequest::default().to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
drop(srv); drop(srv);
@ -573,7 +573,7 @@ mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn test_data() { async fn test_data() {
let mut srv = init_service(App::new().app_data(10usize).service( let srv = init_service(App::new().app_data(10usize).service(
web::resource("/").to(|req: HttpRequest| { web::resource("/").to(|req: HttpRequest| {
if req.app_data::<usize>().is_some() { if req.app_data::<usize>().is_some() {
HttpResponse::Ok() HttpResponse::Ok()
@ -585,10 +585,10 @@ mod tests {
.await; .await;
let req = TestRequest::default().to_request(); let req = TestRequest::default().to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
let mut srv = init_service(App::new().app_data(10u32).service( let srv = init_service(App::new().app_data(10u32).service(
web::resource("/").to(|req: HttpRequest| { web::resource("/").to(|req: HttpRequest| {
if req.app_data::<usize>().is_some() { if req.app_data::<usize>().is_some() {
HttpResponse::Ok() HttpResponse::Ok()
@ -600,7 +600,7 @@ mod tests {
.await; .await;
let req = TestRequest::default().to_request(); let req = TestRequest::default().to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::BAD_REQUEST); assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
} }
@ -612,7 +612,7 @@ mod tests {
HttpResponse::Ok().body(num.to_string()) HttpResponse::Ok().body(num.to_string())
} }
let mut srv = init_service( let srv = init_service(
App::new() App::new()
.app_data(88usize) .app_data(88usize)
.service(web::resource("/").route(web::get().to(echo_usize))) .service(web::resource("/").route(web::get().to(echo_usize)))
@ -643,7 +643,7 @@ mod tests {
HttpResponse::Ok().body(num.to_string()) HttpResponse::Ok().body(num.to_string())
} }
let mut srv = init_service( let srv = init_service(
App::new() App::new()
.app_data(88usize) .app_data(88usize)
.service(web::resource("/").route(web::get().to(echo_usize))) .service(web::resource("/").route(web::get().to(echo_usize)))
@ -683,7 +683,7 @@ mod tests {
let tracker = Rc::new(RefCell::new(Tracker { dropped: false })); let tracker = Rc::new(RefCell::new(Tracker { dropped: false }));
{ {
let tracker2 = Rc::clone(&tracker); let tracker2 = Rc::clone(&tracker);
let mut srv = init_service(App::new().data(10u32).service( let srv = init_service(App::new().data(10u32).service(
web::resource("/").to(move |req: HttpRequest| { web::resource("/").to(move |req: HttpRequest| {
req.extensions_mut().insert(Foo { req.extensions_mut().insert(Foo {
tracker: Rc::clone(&tracker2), tracker: Rc::clone(&tracker2),
@ -694,7 +694,7 @@ mod tests {
.await; .await;
let req = TestRequest::default().to_request(); let req = TestRequest::default().to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
} }
@ -703,7 +703,7 @@ mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn extract_path_pattern() { async fn extract_path_pattern() {
let mut srv = init_service( let srv = init_service(
App::new().service( App::new().service(
web::scope("/user/{id}") web::scope("/user/{id}")
.service(web::resource("/profile").route(web::get().to( .service(web::resource("/profile").route(web::get().to(
@ -725,17 +725,17 @@ mod tests {
.await; .await;
let req = TestRequest::get().uri("/user/22/profile").to_request(); let req = TestRequest::get().uri("/user/22/profile").to_request();
let res = call_service(&mut srv, req).await; let res = call_service(&srv, req).await;
assert_eq!(res.status(), StatusCode::OK); assert_eq!(res.status(), StatusCode::OK);
let req = TestRequest::get().uri("/user/22/not-exist").to_request(); let req = TestRequest::get().uri("/user/22/not-exist").to_request();
let res = call_service(&mut srv, req).await; let res = call_service(&srv, req).await;
assert_eq!(res.status(), StatusCode::OK); assert_eq!(res.status(), StatusCode::OK);
} }
#[actix_rt::test] #[actix_rt::test]
async fn extract_path_pattern_complex() { async fn extract_path_pattern_complex() {
let mut srv = init_service( let srv = init_service(
App::new() App::new()
.service(web::scope("/user").service(web::scope("/{id}").service( .service(web::scope("/user").service(web::scope("/{id}").service(
web::resource("").to(move |req: HttpRequest| { web::resource("").to(move |req: HttpRequest| {
@ -757,15 +757,15 @@ mod tests {
.await; .await;
let req = TestRequest::get().uri("/user/test").to_request(); let req = TestRequest::get().uri("/user/test").to_request();
let res = call_service(&mut srv, req).await; let res = call_service(&srv, req).await;
assert_eq!(res.status(), StatusCode::OK); assert_eq!(res.status(), StatusCode::OK);
let req = TestRequest::get().uri("/").to_request(); let req = TestRequest::get().uri("/").to_request();
let res = call_service(&mut srv, req).await; let res = call_service(&srv, req).await;
assert_eq!(res.status(), StatusCode::OK); assert_eq!(res.status(), StatusCode::OK);
let req = TestRequest::get().uri("/not-exist").to_request(); let req = TestRequest::get().uri("/not-exist").to_request();
let res = call_service(&mut srv, req).await; let res = call_service(&srv, req).await;
assert_eq!(res.status(), StatusCode::OK); assert_eq!(res.status(), StatusCode::OK);
} }
} }

4
src/request_data.rs
View File

@ -102,7 +102,7 @@ mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn req_data_extractor() { async fn req_data_extractor() {
let mut srv = init_service( let srv = init_service(
App::new() App::new()
.wrap_fn(|req, srv| { .wrap_fn(|req, srv| {
if req.method() == Method::POST { if req.method() == Method::POST {
@ -142,7 +142,7 @@ mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn req_data_internal_mutability() { async fn req_data_internal_mutability() {
let mut srv = init_service( let srv = init_service(
App::new() App::new()
.wrap_fn(|req, srv| { .wrap_fn(|req, srv| {
let data_before = Rc::new(RefCell::new(42u32)); let data_before = Rc::new(RefCell::new(42u32));

74
src/resource.rs
View File

@ -328,7 +328,7 @@ where
>, >,
> >
where where
F: FnMut(ServiceRequest, &mut T::Service) -> R + Clone, F: Fn(ServiceRequest, &T::Service) -> R + Clone,
R: Future<Output = Result<ServiceResponse, Error>>, R: Future<Output = Result<ServiceResponse, Error>>,
{ {
Resource { Resource {
@ -350,11 +350,11 @@ where
where where
F: IntoServiceFactory<U, ServiceRequest>, F: IntoServiceFactory<U, ServiceRequest>,
U: ServiceFactory< U: ServiceFactory<
ServiceRequest, ServiceRequest,
Config = (), Config = (),
Response = ServiceResponse, Response = ServiceResponse,
Error = Error, Error = Error,
> + 'static, > + 'static,
U::InitError: fmt::Debug, U::InitError: fmt::Debug,
{ {
// create and configure default resource // create and configure default resource
@ -369,12 +369,12 @@ where
impl<T> HttpServiceFactory for Resource<T> impl<T> HttpServiceFactory for Resource<T>
where where
T: ServiceFactory< T: ServiceFactory<
ServiceRequest, ServiceRequest,
Config = (), Config = (),
Response = ServiceResponse, Response = ServiceResponse,
Error = Error, Error = Error,
InitError = (), InitError = (),
> + 'static, > + 'static,
{ {
fn register(mut self, config: &mut AppService) { fn register(mut self, config: &mut AppService) {
let guards = if self.guards.is_empty() { let guards = if self.guards.is_empty() {
@ -473,8 +473,8 @@ impl Service<ServiceRequest> for ResourceService {
actix_service::always_ready!(); actix_service::always_ready!();
fn call(&mut self, mut req: ServiceRequest) -> Self::Future { fn call(&self, mut req: ServiceRequest) -> Self::Future {
for route in self.routes.iter_mut() { for route in self.routes.iter() {
if route.check(&mut req) { if route.check(&mut req) {
if let Some(ref app_data) = self.app_data { if let Some(ref app_data) = self.app_data {
req.add_data_container(app_data.clone()); req.add_data_container(app_data.clone());
@ -529,7 +529,7 @@ mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn test_middleware() { async fn test_middleware() {
let mut srv = let srv =
init_service( init_service(
App::new().service( App::new().service(
web::resource("/test") web::resource("/test")
@ -543,7 +543,7 @@ mod tests {
) )
.await; .await;
let req = TestRequest::with_uri("/test").to_request(); let req = TestRequest::with_uri("/test").to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
assert_eq!( assert_eq!(
resp.headers().get(header::CONTENT_TYPE).unwrap(), resp.headers().get(header::CONTENT_TYPE).unwrap(),
@ -553,7 +553,7 @@ mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn test_middleware_fn() { async fn test_middleware_fn() {
let mut srv = init_service( let srv = init_service(
App::new().service( App::new().service(
web::resource("/test") web::resource("/test")
.wrap_fn(|req, srv| { .wrap_fn(|req, srv| {
@ -573,7 +573,7 @@ mod tests {
) )
.await; .await;
let req = TestRequest::with_uri("/test").to_request(); let req = TestRequest::with_uri("/test").to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
assert_eq!( assert_eq!(
resp.headers().get(header::CONTENT_TYPE).unwrap(), resp.headers().get(header::CONTENT_TYPE).unwrap(),
@ -583,20 +583,20 @@ mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn test_to() { async fn test_to() {
let mut srv = let srv =
init_service(App::new().service(web::resource("/test").to(|| async { init_service(App::new().service(web::resource("/test").to(|| async {
sleep(Duration::from_millis(100)).await; sleep(Duration::from_millis(100)).await;
Ok::<_, Error>(HttpResponse::Ok()) Ok::<_, Error>(HttpResponse::Ok())
}))) })))
.await; .await;
let req = TestRequest::with_uri("/test").to_request(); let req = TestRequest::with_uri("/test").to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
} }
#[actix_rt::test] #[actix_rt::test]
async fn test_pattern() { async fn test_pattern() {
let mut srv = init_service( let srv = init_service(
App::new().service( App::new().service(
web::resource(["/test", "/test2"]) web::resource(["/test", "/test2"])
.to(|| async { Ok::<_, Error>(HttpResponse::Ok()) }), .to(|| async { Ok::<_, Error>(HttpResponse::Ok()) }),
@ -604,16 +604,16 @@ mod tests {
) )
.await; .await;
let req = TestRequest::with_uri("/test").to_request(); let req = TestRequest::with_uri("/test").to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
let req = TestRequest::with_uri("/test2").to_request(); let req = TestRequest::with_uri("/test2").to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
} }
#[actix_rt::test] #[actix_rt::test]
async fn test_default_resource() { async fn test_default_resource() {
let mut srv = init_service( let srv = init_service(
App::new() App::new()
.service(web::resource("/test").route(web::get().to(HttpResponse::Ok))) .service(web::resource("/test").route(web::get().to(HttpResponse::Ok)))
.default_service(|r: ServiceRequest| { .default_service(|r: ServiceRequest| {
@ -622,16 +622,16 @@ mod tests {
) )
.await; .await;
let req = TestRequest::with_uri("/test").to_request(); let req = TestRequest::with_uri("/test").to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
let req = TestRequest::with_uri("/test") let req = TestRequest::with_uri("/test")
.method(Method::POST) .method(Method::POST)
.to_request(); .to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::METHOD_NOT_ALLOWED); assert_eq!(resp.status(), StatusCode::METHOD_NOT_ALLOWED);
let mut srv = init_service( let srv = init_service(
App::new().service( App::new().service(
web::resource("/test") web::resource("/test")
.route(web::get().to(HttpResponse::Ok)) .route(web::get().to(HttpResponse::Ok))
@ -643,19 +643,19 @@ mod tests {
.await; .await;
let req = TestRequest::with_uri("/test").to_request(); let req = TestRequest::with_uri("/test").to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
let req = TestRequest::with_uri("/test") let req = TestRequest::with_uri("/test")
.method(Method::POST) .method(Method::POST)
.to_request(); .to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::BAD_REQUEST); assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
} }
#[actix_rt::test] #[actix_rt::test]
async fn test_resource_guards() { async fn test_resource_guards() {
let mut srv = init_service( let srv = init_service(
App::new() App::new()
.service( .service(
web::resource("/test/{p}") web::resource("/test/{p}")
@ -678,25 +678,25 @@ mod tests {
let req = TestRequest::with_uri("/test/it") let req = TestRequest::with_uri("/test/it")
.method(Method::GET) .method(Method::GET)
.to_request(); .to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
let req = TestRequest::with_uri("/test/it") let req = TestRequest::with_uri("/test/it")
.method(Method::PUT) .method(Method::PUT)
.to_request(); .to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::CREATED); assert_eq!(resp.status(), StatusCode::CREATED);
let req = TestRequest::with_uri("/test/it") let req = TestRequest::with_uri("/test/it")
.method(Method::DELETE) .method(Method::DELETE)
.to_request(); .to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::NO_CONTENT); assert_eq!(resp.status(), StatusCode::NO_CONTENT);
} }
#[actix_rt::test] #[actix_rt::test]
async fn test_data() { async fn test_data() {
let mut srv = init_service( let srv = init_service(
App::new() App::new()
.data(1.0f64) .data(1.0f64)
.data(1usize) .data(1usize)
@ -722,13 +722,13 @@ mod tests {
.await; .await;
let req = TestRequest::get().uri("/test").to_request(); let req = TestRequest::get().uri("/test").to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
} }
#[actix_rt::test] #[actix_rt::test]
async fn test_data_default_service() { async fn test_data_default_service() {
let mut srv = init_service( let srv = init_service(
App::new().data(1usize).service( App::new().data(1usize).service(
web::resource("/test") web::resource("/test")
.data(10usize) .data(10usize)
@ -741,7 +741,7 @@ mod tests {
.await; .await;
let req = TestRequest::get().uri("/test").to_request(); let req = TestRequest::get().uri("/test").to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
} }
} }

2
src/responder.rs
View File

@ -270,7 +270,7 @@ pub(crate) mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn test_option_responder() { async fn test_option_responder() {
let mut srv = init_service( let srv = init_service(
App::new() App::new()
.service( .service(
web::resource("/none").to(|| async { Option::<&'static str>::None }), web::resource("/none").to(|| async { Option::<&'static str>::None }),

22
src/route.rs
View File

@ -121,11 +121,11 @@ impl Service<ServiceRequest> for RouteService {
type Error = Error; type Error = Error;
type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>; type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.service.poll_ready(cx) self.service.poll_ready(cx)
} }
fn call(&mut self, req: ServiceRequest) -> Self::Future { fn call(&self, req: ServiceRequest) -> Self::Future {
self.service.call(req) self.service.call(req)
} }
} }
@ -299,11 +299,11 @@ where
type Error = Error; type Error = Error;
type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>; type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> { fn poll_ready(&self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
self.service.poll_ready(cx) self.service.poll_ready(cx)
} }
fn call(&mut self, req: ServiceRequest) -> Self::Future { fn call(&self, req: ServiceRequest) -> Self::Future {
Box::pin(self.service.call(req)) Box::pin(self.service.call(req))
} }
} }
@ -327,7 +327,7 @@ mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn test_route() { async fn test_route() {
let mut srv = init_service( let srv = init_service(
App::new() App::new()
.service( .service(
web::resource("/test") web::resource("/test")
@ -356,35 +356,35 @@ mod tests {
let req = TestRequest::with_uri("/test") let req = TestRequest::with_uri("/test")
.method(Method::GET) .method(Method::GET)
.to_request(); .to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
let req = TestRequest::with_uri("/test") let req = TestRequest::with_uri("/test")
.method(Method::POST) .method(Method::POST)
.to_request(); .to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::CREATED); assert_eq!(resp.status(), StatusCode::CREATED);
let req = TestRequest::with_uri("/test") let req = TestRequest::with_uri("/test")
.method(Method::PUT) .method(Method::PUT)
.to_request(); .to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::BAD_REQUEST); assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
let req = TestRequest::with_uri("/test") let req = TestRequest::with_uri("/test")
.method(Method::DELETE) .method(Method::DELETE)
.to_request(); .to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::BAD_REQUEST); assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
let req = TestRequest::with_uri("/test") let req = TestRequest::with_uri("/test")
.method(Method::HEAD) .method(Method::HEAD)
.to_request(); .to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::METHOD_NOT_ALLOWED); assert_eq!(resp.status(), StatusCode::METHOD_NOT_ALLOWED);
let req = TestRequest::with_uri("/json").to_request(); let req = TestRequest::with_uri("/json").to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
let body = read_body(resp).await; let body = read_body(resp).await;

149
src/scope.rs
View File

@ -287,11 +287,11 @@ where
where where
F: IntoServiceFactory<U, ServiceRequest>, F: IntoServiceFactory<U, ServiceRequest>,
U: ServiceFactory< U: ServiceFactory<
ServiceRequest, ServiceRequest,
Config = (), Config = (),
Response = ServiceResponse, Response = ServiceResponse,
Error = Error, Error = Error,
> + 'static, > + 'static,
U::InitError: fmt::Debug, U::InitError: fmt::Debug,
{ {
// create and configure default resource // create and configure default resource
@ -389,7 +389,7 @@ where
>, >,
> >
where where
F: FnMut(ServiceRequest, &mut T::Service) -> R + Clone, F: Fn(ServiceRequest, &T::Service) -> R + Clone,
R: Future<Output = Result<ServiceResponse, Error>>, R: Future<Output = Result<ServiceResponse, Error>>,
{ {
Scope { Scope {
@ -408,12 +408,12 @@ where
impl<T> HttpServiceFactory for Scope<T> impl<T> HttpServiceFactory for Scope<T>
where where
T: ServiceFactory< T: ServiceFactory<
ServiceRequest, ServiceRequest,
Config = (), Config = (),
Response = ServiceResponse, Response = ServiceResponse,
Error = Error, Error = Error,
InitError = (), InitError = (),
> + 'static, > + 'static,
{ {
fn register(mut self, config: &mut AppService) { fn register(mut self, config: &mut AppService) {
// update default resource if needed // update default resource if needed
@ -540,7 +540,7 @@ impl Service<ServiceRequest> for ScopeService {
actix_service::always_ready!(); actix_service::always_ready!();
fn call(&mut self, mut req: ServiceRequest) -> Self::Future { fn call(&self, mut req: ServiceRequest) -> Self::Future {
let res = self.router.recognize_mut_checked(&mut req, |req, guards| { let res = self.router.recognize_mut_checked(&mut req, |req, guards| {
if let Some(ref guards) = guards { if let Some(ref guards) = guards {
for f in guards { for f in guards {
@ -603,7 +603,7 @@ mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn test_scope() { async fn test_scope() {
let mut srv = init_service(App::new().service( let srv = init_service(App::new().service(
web::scope("/app").service(web::resource("/path1").to(HttpResponse::Ok)), web::scope("/app").service(web::resource("/path1").to(HttpResponse::Ok)),
)) ))
.await; .await;
@ -615,7 +615,7 @@ mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn test_scope_root() { async fn test_scope_root() {
let mut srv = init_service( let srv = init_service(
App::new().service( App::new().service(
web::scope("/app") web::scope("/app")
.service(web::resource("").to(HttpResponse::Ok)) .service(web::resource("").to(HttpResponse::Ok))
@ -635,7 +635,7 @@ mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn test_scope_root2() { async fn test_scope_root2() {
let mut srv = init_service(App::new().service( let srv = init_service(App::new().service(
web::scope("/app/").service(web::resource("").to(HttpResponse::Ok)), web::scope("/app/").service(web::resource("").to(HttpResponse::Ok)),
)) ))
.await; .await;
@ -651,7 +651,7 @@ mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn test_scope_root3() { async fn test_scope_root3() {
let mut srv = init_service(App::new().service( let srv = init_service(App::new().service(
web::scope("/app/").service(web::resource("/").to(HttpResponse::Ok)), web::scope("/app/").service(web::resource("/").to(HttpResponse::Ok)),
)) ))
.await; .await;
@ -667,7 +667,7 @@ mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn test_scope_route() { async fn test_scope_route() {
let mut srv = init_service( let srv = init_service(
App::new().service( App::new().service(
web::scope("app") web::scope("app")
.route("/path1", web::get().to(HttpResponse::Ok)) .route("/path1", web::get().to(HttpResponse::Ok))
@ -695,7 +695,7 @@ mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn test_scope_route_without_leading_slash() { async fn test_scope_route_without_leading_slash() {
let mut srv = init_service( let srv = init_service(
App::new().service( App::new().service(
web::scope("app").service( web::scope("app").service(
web::resource("path1") web::resource("path1")
@ -725,7 +725,7 @@ mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn test_scope_guard() { async fn test_scope_guard() {
let mut srv = init_service( let srv = init_service(
App::new().service( App::new().service(
web::scope("/app") web::scope("/app")
.guard(guard::Get()) .guard(guard::Get())
@ -749,14 +749,13 @@ mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn test_scope_variable_segment() { async fn test_scope_variable_segment() {
let mut srv = let srv = init_service(App::new().service(web::scope("/ab-{project}").service(
init_service(App::new().service(web::scope("/ab-{project}").service( web::resource("/path1").to(|r: HttpRequest| {
web::resource("/path1").to(|r: HttpRequest| { HttpResponse::Ok()
HttpResponse::Ok() .body(format!("project: {}", &r.match_info()["project"]))
.body(format!("project: {}", &r.match_info()["project"])) }),
}), )))
))) .await;
.await;
let req = TestRequest::with_uri("/ab-project1/path1").to_request(); let req = TestRequest::with_uri("/ab-project1/path1").to_request();
let resp = srv.call(req).await.unwrap(); let resp = srv.call(req).await.unwrap();
@ -777,7 +776,7 @@ mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn test_nested_scope() { async fn test_nested_scope() {
let mut srv = init_service(App::new().service(web::scope("/app").service( let srv = init_service(App::new().service(web::scope("/app").service(
web::scope("/t1").service(web::resource("/path1").to(HttpResponse::Created)), web::scope("/t1").service(web::resource("/path1").to(HttpResponse::Created)),
))) )))
.await; .await;
@ -789,7 +788,7 @@ mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn test_nested_scope_no_slash() { async fn test_nested_scope_no_slash() {
let mut srv = init_service(App::new().service(web::scope("/app").service( let srv = init_service(App::new().service(web::scope("/app").service(
web::scope("t1").service(web::resource("/path1").to(HttpResponse::Created)), web::scope("t1").service(web::resource("/path1").to(HttpResponse::Created)),
))) )))
.await; .await;
@ -801,7 +800,7 @@ mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn test_nested_scope_root() { async fn test_nested_scope_root() {
let mut srv = init_service( let srv = init_service(
App::new().service( App::new().service(
web::scope("/app").service( web::scope("/app").service(
web::scope("/t1") web::scope("/t1")
@ -823,7 +822,7 @@ mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn test_nested_scope_filter() { async fn test_nested_scope_filter() {
let mut srv = init_service( let srv = init_service(
App::new().service( App::new().service(
web::scope("/app").service( web::scope("/app").service(
web::scope("/t1") web::scope("/t1")
@ -849,7 +848,7 @@ mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn test_nested_scope_with_variable_segment() { async fn test_nested_scope_with_variable_segment() {
let mut srv = init_service(App::new().service(web::scope("/app").service( let srv = init_service(App::new().service(web::scope("/app").service(
web::scope("/{project_id}").service(web::resource("/path1").to( web::scope("/{project_id}").service(web::resource("/path1").to(
|r: HttpRequest| { |r: HttpRequest| {
HttpResponse::Created() HttpResponse::Created()
@ -874,7 +873,7 @@ mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn test_nested2_scope_with_variable_segment() { async fn test_nested2_scope_with_variable_segment() {
let mut srv = init_service(App::new().service(web::scope("/app").service( let srv = init_service(App::new().service(web::scope("/app").service(
web::scope("/{project}").service(web::scope("/{id}").service( web::scope("/{project}").service(web::scope("/{id}").service(
web::resource("/path1").to(|r: HttpRequest| { web::resource("/path1").to(|r: HttpRequest| {
HttpResponse::Created().body(format!( HttpResponse::Created().body(format!(
@ -906,7 +905,7 @@ mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn test_default_resource() { async fn test_default_resource() {
let mut srv = init_service( let srv = init_service(
App::new().service( App::new().service(
web::scope("/app") web::scope("/app")
.service(web::resource("/path1").to(HttpResponse::Ok)) .service(web::resource("/path1").to(HttpResponse::Ok))
@ -928,7 +927,7 @@ mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn test_default_resource_propagation() { async fn test_default_resource_propagation() {
let mut srv = init_service( let srv = init_service(
App::new() App::new()
.service( .service(
web::scope("/app1") web::scope("/app1")
@ -956,7 +955,7 @@ mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn test_middleware() { async fn test_middleware() {
let mut srv = init_service( let srv = init_service(
App::new().service( App::new().service(
web::scope("app") web::scope("app")
.wrap( .wrap(
@ -973,7 +972,7 @@ mod tests {
.await; .await;
let req = TestRequest::with_uri("/app/test").to_request(); let req = TestRequest::with_uri("/app/test").to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
assert_eq!( assert_eq!(
resp.headers().get(header::CONTENT_TYPE).unwrap(), resp.headers().get(header::CONTENT_TYPE).unwrap(),
@ -983,7 +982,7 @@ mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn test_middleware_fn() { async fn test_middleware_fn() {
let mut srv = init_service( let srv = init_service(
App::new().service( App::new().service(
web::scope("app") web::scope("app")
.wrap_fn(|req, srv| { .wrap_fn(|req, srv| {
@ -1003,7 +1002,7 @@ mod tests {
.await; .await;
let req = TestRequest::with_uri("/app/test").to_request(); let req = TestRequest::with_uri("/app/test").to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
assert_eq!( assert_eq!(
resp.headers().get(header::CONTENT_TYPE).unwrap(), resp.headers().get(header::CONTENT_TYPE).unwrap(),
@ -1013,7 +1012,7 @@ mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn test_override_data() { async fn test_override_data() {
let mut srv = init_service(App::new().data(1usize).service( let srv = init_service(App::new().data(1usize).service(
web::scope("app").data(10usize).route( web::scope("app").data(10usize).route(
"/t", "/t",
web::get().to(|data: web::Data<usize>| { web::get().to(|data: web::Data<usize>| {
@ -1025,13 +1024,13 @@ mod tests {
.await; .await;
let req = TestRequest::with_uri("/app/t").to_request(); let req = TestRequest::with_uri("/app/t").to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
} }
#[actix_rt::test] #[actix_rt::test]
async fn test_override_data_default_service() { async fn test_override_data_default_service() {
let mut srv = init_service(App::new().data(1usize).service( let srv = init_service(App::new().data(1usize).service(
web::scope("app").data(10usize).default_service(web::to( web::scope("app").data(10usize).default_service(web::to(
|data: web::Data<usize>| { |data: web::Data<usize>| {
assert_eq!(**data, 10); assert_eq!(**data, 10);
@ -1042,13 +1041,13 @@ mod tests {
.await; .await;
let req = TestRequest::with_uri("/app/t").to_request(); let req = TestRequest::with_uri("/app/t").to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
} }
#[actix_rt::test] #[actix_rt::test]
async fn test_override_app_data() { async fn test_override_app_data() {
let mut srv = init_service(App::new().app_data(web::Data::new(1usize)).service( let srv = init_service(App::new().app_data(web::Data::new(1usize)).service(
web::scope("app").app_data(web::Data::new(10usize)).route( web::scope("app").app_data(web::Data::new(10usize)).route(
"/t", "/t",
web::get().to(|data: web::Data<usize>| { web::get().to(|data: web::Data<usize>| {
@ -1060,17 +1059,16 @@ mod tests {
.await; .await;
let req = TestRequest::with_uri("/app/t").to_request(); let req = TestRequest::with_uri("/app/t").to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
} }
#[actix_rt::test] #[actix_rt::test]
async fn test_scope_config() { async fn test_scope_config() {
let mut srv = let srv = init_service(App::new().service(web::scope("/app").configure(|s| {
init_service(App::new().service(web::scope("/app").configure(|s| { s.route("/path1", web::get().to(HttpResponse::Ok));
s.route("/path1", web::get().to(HttpResponse::Ok)); })))
}))) .await;
.await;
let req = TestRequest::with_uri("/app/path1").to_request(); let req = TestRequest::with_uri("/app/path1").to_request();
let resp = srv.call(req).await.unwrap(); let resp = srv.call(req).await.unwrap();
@ -1079,13 +1077,12 @@ mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn test_scope_config_2() { async fn test_scope_config_2() {
let mut srv = let srv = init_service(App::new().service(web::scope("/app").configure(|s| {
init_service(App::new().service(web::scope("/app").configure(|s| { s.service(web::scope("/v1").configure(|s| {
s.service(web::scope("/v1").configure(|s| { s.route("/", web::get().to(HttpResponse::Ok));
s.route("/", web::get().to(HttpResponse::Ok)); }));
})); })))
}))) .await;
.await;
let req = TestRequest::with_uri("/app/v1/").to_request(); let req = TestRequest::with_uri("/app/v1/").to_request();
let resp = srv.call(req).await.unwrap(); let resp = srv.call(req).await.unwrap();
@ -1094,24 +1091,20 @@ mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn test_url_for_external() { async fn test_url_for_external() {
let mut srv = let srv = init_service(App::new().service(web::scope("/app").configure(|s| {
init_service(App::new().service(web::scope("/app").configure(|s| { s.service(web::scope("/v1").configure(|s| {
s.service(web::scope("/v1").configure(|s| { s.external_resource("youtube", "https://youtube.com/watch/{video_id}");
s.external_resource( s.route(
"youtube", "/",
"https://youtube.com/watch/{video_id}", web::get().to(|req: HttpRequest| {
); HttpResponse::Ok().body(
s.route( req.url_for("youtube", &["xxxxxx"]).unwrap().to_string(),
"/", )
web::get().to(|req: HttpRequest| { }),
HttpResponse::Ok().body( );
req.url_for("youtube", &["xxxxxx"]).unwrap().to_string(), }));
) })))
}), .await;
);
}));
})))
.await;
let req = TestRequest::with_uri("/app/v1/").to_request(); let req = TestRequest::with_uri("/app/v1/").to_request();
let resp = srv.call(req).await.unwrap(); let resp = srv.call(req).await.unwrap();
@ -1122,7 +1115,7 @@ mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn test_url_for_nested() { async fn test_url_for_nested() {
let mut srv = init_service(App::new().service(web::scope("/a").service( let srv = init_service(App::new().service(web::scope("/a").service(
web::scope("/b").service(web::resource("/c/{stuff}").name("c").route( web::scope("/b").service(web::resource("/c/{stuff}").name("c").route(
web::get().to(|req: HttpRequest| { web::get().to(|req: HttpRequest| {
HttpResponse::Ok() HttpResponse::Ok()
@ -1133,7 +1126,7 @@ mod tests {
.await; .await;
let req = TestRequest::with_uri("/a/b/c/test").to_request(); let req = TestRequest::with_uri("/a/b/c/test").to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
let body = read_body(resp).await; let body = read_body(resp).await;
assert_eq!( assert_eq!(

2
src/server.rs
View File

@ -630,7 +630,7 @@ where
/// } /// }
/// ``` /// ```
pub fn run(self) -> Server { pub fn run(self) -> Server {
self.builder.start() self.builder.run()
} }
} }

30
src/service.rs
View File

@ -478,12 +478,12 @@ impl WebService {
where where
F: IntoServiceFactory<T, ServiceRequest>, F: IntoServiceFactory<T, ServiceRequest>,
T: ServiceFactory< T: ServiceFactory<
ServiceRequest, ServiceRequest,
Config = (), Config = (),
Response = ServiceResponse, Response = ServiceResponse,
Error = Error, Error = Error,
InitError = (), InitError = (),
> + 'static, > + 'static,
{ {
WebServiceImpl { WebServiceImpl {
srv: service.into_factory(), srv: service.into_factory(),
@ -504,12 +504,12 @@ struct WebServiceImpl<T> {
impl<T> HttpServiceFactory for WebServiceImpl<T> impl<T> HttpServiceFactory for WebServiceImpl<T>
where where
T: ServiceFactory< T: ServiceFactory<
ServiceRequest, ServiceRequest,
Config = (), Config = (),
Response = ServiceResponse, Response = ServiceResponse,
Error = Error, Error = Error,
InitError = (), InitError = (),
> + 'static, > + 'static,
{ {
fn register(mut self, config: &mut AppService) { fn register(mut self, config: &mut AppService) {
let guards = if self.guards.is_empty() { let guards = if self.guards.is_empty() {
@ -540,7 +540,7 @@ mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn test_service() { async fn test_service() {
let mut srv = init_service( let srv = init_service(
App::new().service(web::service("/test").name("test").finish( App::new().service(web::service("/test").name("test").finish(
|req: ServiceRequest| ok(req.into_response(HttpResponse::Ok().finish())), |req: ServiceRequest| ok(req.into_response(HttpResponse::Ok().finish())),
)), )),
@ -550,7 +550,7 @@ mod tests {
let resp = srv.call(req).await.unwrap(); let resp = srv.call(req).await.unwrap();
assert_eq!(resp.status(), http::StatusCode::OK); assert_eq!(resp.status(), http::StatusCode::OK);
let mut srv = init_service( let srv = init_service(
App::new().service(web::service("/test").guard(guard::Get()).finish( App::new().service(web::service("/test").guard(guard::Get()).finish(
|req: ServiceRequest| ok(req.into_response(HttpResponse::Ok().finish())), |req: ServiceRequest| ok(req.into_response(HttpResponse::Ok().finish())),
)), )),
@ -565,7 +565,7 @@ mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn test_service_data() { async fn test_service_data() {
let mut srv = init_service( let srv = init_service(
App::new() App::new()
.data(42u32) .data(42u32)
.service(web::service("/test").name("test").finish( .service(web::service("/test").name("test").finish(

68
src/test.rs
View File

@ -60,7 +60,7 @@ pub fn default_service(
/// ///
/// #[actix_rt::test] /// #[actix_rt::test]
/// async fn test_init_service() { /// async fn test_init_service() {
/// let mut app = test::init_service( /// let app = test::init_service(
/// App::new() /// App::new()
/// .service(web::resource("/test").to(|| async { HttpResponse::Ok() })) /// .service(web::resource("/test").to(|| async { HttpResponse::Ok() }))
/// ).await; /// ).await;
@ -116,7 +116,7 @@ where
/// ///
/// #[actix_rt::test] /// #[actix_rt::test]
/// async fn test_response() { /// async fn test_response() {
/// let mut app = test::init_service( /// let app = test::init_service(
/// App::new() /// App::new()
/// .service(web::resource("/test").to(|| async { /// .service(web::resource("/test").to(|| async {
/// HttpResponse::Ok() /// HttpResponse::Ok()
@ -127,11 +127,11 @@ where
/// let req = test::TestRequest::with_uri("/test").to_request(); /// let req = test::TestRequest::with_uri("/test").to_request();
/// ///
/// // Call application /// // Call application
/// let resp = test::call_service(&mut app, req).await; /// let resp = test::call_service(&app, req).await;
/// assert_eq!(resp.status(), StatusCode::OK); /// assert_eq!(resp.status(), StatusCode::OK);
/// } /// }
/// ``` /// ```
pub async fn call_service<S, R, B, E>(app: &mut S, req: R) -> S::Response pub async fn call_service<S, R, B, E>(app: &S, req: R) -> S::Response
where where
S: Service<R, Response = ServiceResponse<B>, Error = E>, S: Service<R, Response = ServiceResponse<B>, Error = E>,
E: std::fmt::Debug, E: std::fmt::Debug,
@ -147,7 +147,7 @@ where
/// ///
/// #[actix_rt::test] /// #[actix_rt::test]
/// async fn test_index() { /// async fn test_index() {
/// let mut app = test::init_service( /// let app = test::init_service(
/// App::new().service( /// App::new().service(
/// web::resource("/index.html") /// web::resource("/index.html")
/// .route(web::post().to(|| async { /// .route(web::post().to(|| async {
@ -164,7 +164,7 @@ where
/// assert_eq!(result, Bytes::from_static(b"welcome!")); /// assert_eq!(result, Bytes::from_static(b"welcome!"));
/// } /// }
/// ``` /// ```
pub async fn read_response<S, B>(app: &mut S, req: Request) -> Bytes pub async fn read_response<S, B>(app: &S, req: Request) -> Bytes
where where
S: Service<Request, Response = ServiceResponse<B>, Error = Error>, S: Service<Request, Response = ServiceResponse<B>, Error = Error>,
B: MessageBody + Unpin, B: MessageBody + Unpin,
@ -190,7 +190,7 @@ where
/// ///
/// #[actix_rt::test] /// #[actix_rt::test]
/// async fn test_index() { /// async fn test_index() {
/// let mut app = test::init_service( /// let app = test::init_service(
/// App::new().service( /// App::new().service(
/// web::resource("/index.html") /// web::resource("/index.html")
/// .route(web::post().to(|| async { /// .route(web::post().to(|| async {
@ -203,7 +203,7 @@ where
/// .header(header::CONTENT_TYPE, "application/json") /// .header(header::CONTENT_TYPE, "application/json")
/// .to_request(); /// .to_request();
/// ///
/// let resp = test::call_service(&mut app, req).await; /// let resp = test::call_service(&app, req).await;
/// let result = test::read_body(resp).await; /// let result = test::read_body(resp).await;
/// assert_eq!(result, Bytes::from_static(b"welcome!")); /// assert_eq!(result, Bytes::from_static(b"welcome!"));
/// } /// }
@ -234,7 +234,7 @@ where
/// ///
/// #[actix_rt::test] /// #[actix_rt::test]
/// async fn test_post_person() { /// async fn test_post_person() {
/// let mut app = test::init_service( /// let app = test::init_service(
/// App::new().service( /// App::new().service(
/// web::resource("/people") /// web::resource("/people")
/// .route(web::post().to(|person: web::Json<Person>| async { /// .route(web::post().to(|person: web::Json<Person>| async {
@ -294,7 +294,7 @@ where
/// ///
/// #[actix_rt::test] /// #[actix_rt::test]
/// async fn test_add_person() { /// async fn test_add_person() {
/// let mut app = test::init_service( /// let app = test::init_service(
/// App::new().service( /// App::new().service(
/// web::resource("/people") /// web::resource("/people")
/// .route(web::post().to(|person: web::Json<Person>| async { /// .route(web::post().to(|person: web::Json<Person>| async {
@ -314,7 +314,7 @@ where
/// let result: Person = test::read_response_json(&mut app, req).await; /// let result: Person = test::read_response_json(&mut app, req).await;
/// } /// }
/// ``` /// ```
pub async fn read_response_json<S, B, T>(app: &mut S, req: Request) -> T pub async fn read_response_json<S, B, T>(app: &S, req: Request) -> T
where where
S: Service<Request, Response = ServiceResponse<B>, Error = Error>, S: Service<Request, Response = ServiceResponse<B>, Error = Error>,
B: MessageBody + Unpin, B: MessageBody + Unpin,
@ -583,7 +583,7 @@ impl TestRequest {
} }
/// Complete request creation, calls service and waits for response future completion. /// Complete request creation, calls service and waits for response future completion.
pub async fn send_request<S, B, E>(self, app: &mut S) -> S::Response pub async fn send_request<S, B, E>(self, app: &S) -> S::Response
where where
S: Service<Request, Response = ServiceResponse<B>, Error = E>, S: Service<Request, Response = ServiceResponse<B>, Error = E>,
E: std::fmt::Debug, E: std::fmt::Debug,
@ -609,7 +609,7 @@ impl TestRequest {
/// ///
/// #[actix_rt::test] /// #[actix_rt::test]
/// async fn test_example() { /// async fn test_example() {
/// let mut srv = test::start( /// let srv = test::start(
/// || App::new().service( /// || App::new().service(
/// web::resource("/").to(my_handler)) /// web::resource("/").to(my_handler))
/// ); /// );
@ -649,7 +649,7 @@ where
/// ///
/// #[actix_rt::test] /// #[actix_rt::test]
/// async fn test_example() { /// async fn test_example() {
/// let mut srv = test::start_with(test::config().h1(), || /// let srv = test::start_with(test::config().h1(), ||
/// App::new().service(web::resource("/").to(my_handler)) /// App::new().service(web::resource("/").to(my_handler))
/// ); /// );
/// ///
@ -774,7 +774,7 @@ where
.unwrap(); .unwrap();
sys.block_on(async { sys.block_on(async {
let srv = srv.start(); let srv = srv.run();
tx.send((System::current(), srv, local_addr)).unwrap(); tx.send((System::current(), srv, local_addr)).unwrap();
}); });
@ -1056,7 +1056,7 @@ mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn test_request_methods() { async fn test_request_methods() {
let mut app = init_service( let app = init_service(
App::new().service( App::new().service(
web::resource("/index.html") web::resource("/index.html")
.route(web::put().to(|| HttpResponse::Ok().body("put!"))) .route(web::put().to(|| HttpResponse::Ok().body("put!")))
@ -1071,7 +1071,7 @@ mod tests {
.header(header::CONTENT_TYPE, "application/json") .header(header::CONTENT_TYPE, "application/json")
.to_request(); .to_request();
let result = read_response(&mut app, put_req).await; let result = read_response(&app, put_req).await;
assert_eq!(result, Bytes::from_static(b"put!")); assert_eq!(result, Bytes::from_static(b"put!"));
let patch_req = TestRequest::patch() let patch_req = TestRequest::patch()
@ -1079,17 +1079,17 @@ mod tests {
.header(header::CONTENT_TYPE, "application/json") .header(header::CONTENT_TYPE, "application/json")
.to_request(); .to_request();
let result = read_response(&mut app, patch_req).await; let result = read_response(&app, patch_req).await;
assert_eq!(result, Bytes::from_static(b"patch!")); assert_eq!(result, Bytes::from_static(b"patch!"));
let delete_req = TestRequest::delete().uri("/index.html").to_request(); let delete_req = TestRequest::delete().uri("/index.html").to_request();
let result = read_response(&mut app, delete_req).await; let result = read_response(&app, delete_req).await;
assert_eq!(result, Bytes::from_static(b"delete!")); assert_eq!(result, Bytes::from_static(b"delete!"));
} }
#[actix_rt::test] #[actix_rt::test]
async fn test_response() { async fn test_response() {
let mut app = init_service( let app = init_service(
App::new().service( App::new().service(
web::resource("/index.html") web::resource("/index.html")
.route(web::post().to(|| HttpResponse::Ok().body("welcome!"))), .route(web::post().to(|| HttpResponse::Ok().body("welcome!"))),
@ -1102,13 +1102,13 @@ mod tests {
.header(header::CONTENT_TYPE, "application/json") .header(header::CONTENT_TYPE, "application/json")
.to_request(); .to_request();
let result = read_response(&mut app, req).await; let result = read_response(&app, req).await;
assert_eq!(result, Bytes::from_static(b"welcome!")); assert_eq!(result, Bytes::from_static(b"welcome!"));
} }
#[actix_rt::test] #[actix_rt::test]
async fn test_send_request() { async fn test_send_request() {
let mut app = init_service( let app = init_service(
App::new().service( App::new().service(
web::resource("/index.html") web::resource("/index.html")
.route(web::get().to(|| HttpResponse::Ok().body("welcome!"))), .route(web::get().to(|| HttpResponse::Ok().body("welcome!"))),
@ -1118,7 +1118,7 @@ mod tests {
let resp = TestRequest::get() let resp = TestRequest::get()
.uri("/index.html") .uri("/index.html")
.send_request(&mut app) .send_request(&app)
.await; .await;
let result = read_body(resp).await; let result = read_body(resp).await;
@ -1133,7 +1133,7 @@ mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn test_response_json() { async fn test_response_json() {
let mut app = init_service(App::new().service(web::resource("/people").route( let app = init_service(App::new().service(web::resource("/people").route(
web::post().to(|person: web::Json<Person>| { web::post().to(|person: web::Json<Person>| {
HttpResponse::Ok().json(person.into_inner()) HttpResponse::Ok().json(person.into_inner())
}), }),
@ -1148,13 +1148,13 @@ mod tests {
.set_payload(payload) .set_payload(payload)
.to_request(); .to_request();
let result: Person = read_response_json(&mut app, req).await; let result: Person = read_response_json(&app, req).await;
assert_eq!(&result.id, "12345"); assert_eq!(&result.id, "12345");
} }
#[actix_rt::test] #[actix_rt::test]
async fn test_body_json() { async fn test_body_json() {
let mut app = init_service(App::new().service(web::resource("/people").route( let app = init_service(App::new().service(web::resource("/people").route(
web::post().to(|person: web::Json<Person>| { web::post().to(|person: web::Json<Person>| {
HttpResponse::Ok().json(person.into_inner()) HttpResponse::Ok().json(person.into_inner())
}), }),
@ -1167,7 +1167,7 @@ mod tests {
.uri("/people") .uri("/people")
.header(header::CONTENT_TYPE, "application/json") .header(header::CONTENT_TYPE, "application/json")
.set_payload(payload) .set_payload(payload)
.send_request(&mut app) .send_request(&app)
.await; .await;
let result: Person = read_body_json(resp).await; let result: Person = read_body_json(resp).await;
@ -1176,7 +1176,7 @@ mod tests {
#[actix_rt::test] #[actix_rt::test]
async fn test_request_response_form() { async fn test_request_response_form() {
let mut app = init_service(App::new().service(web::resource("/people").route( let app = init_service(App::new().service(web::resource("/people").route(
web::post().to(|person: web::Form<Person>| { web::post().to(|person: web::Form<Person>| {
HttpResponse::Ok().json(person.into_inner()) HttpResponse::Ok().json(person.into_inner())
}), }),
@ -1195,14 +1195,14 @@ mod tests {
assert_eq!(req.content_type(), "application/x-www-form-urlencoded"); assert_eq!(req.content_type(), "application/x-www-form-urlencoded");
let result: Person = read_response_json(&mut app, req).await; let result: Person = read_response_json(&app, req).await;
assert_eq!(&result.id, "12345"); assert_eq!(&result.id, "12345");
assert_eq!(&result.name, "User name"); assert_eq!(&result.name, "User name");
} }
#[actix_rt::test] #[actix_rt::test]
async fn test_request_response_json() { async fn test_request_response_json() {
let mut app = init_service(App::new().service(web::resource("/people").route( let app = init_service(App::new().service(web::resource("/people").route(
web::post().to(|person: web::Json<Person>| { web::post().to(|person: web::Json<Person>| {
HttpResponse::Ok().json(person.into_inner()) HttpResponse::Ok().json(person.into_inner())
}), }),
@ -1221,7 +1221,7 @@ mod tests {
assert_eq!(req.content_type(), "application/json"); assert_eq!(req.content_type(), "application/json");
let result: Person = read_response_json(&mut app, req).await; let result: Person = read_response_json(&app, req).await;
assert_eq!(&result.id, "12345"); assert_eq!(&result.id, "12345");
assert_eq!(&result.name, "User name"); assert_eq!(&result.name, "User name");
} }
@ -1239,7 +1239,7 @@ mod tests {
} }
} }
let mut app = init_service( let app = init_service(
App::new().service(web::resource("/index.html").to(async_with_block)), App::new().service(web::resource("/index.html").to(async_with_block)),
) )
.await; .await;
@ -1256,7 +1256,7 @@ mod tests {
HttpResponse::Ok() HttpResponse::Ok()
} }
let mut app = init_service( let app = init_service(
App::new() App::new()
.data(10usize) .data(10usize)
.service(web::resource("/index.html").to(handler)), .service(web::resource("/index.html").to(handler)),
@ -1312,7 +1312,7 @@ mod tests {
.data(addr.clone()) .data(addr.clone())
.service(web::resource("/").to(actor_handler)); .service(web::resource("/").to(actor_handler));
let mut app = init_service(srv).await; let app = init_service(srv).await;
let req = TestRequest::post().uri("/").to_request(); let req = TestRequest::post().uri("/").to_request();
let res = app.call(req).await.unwrap(); let res = app.call(req).await.unwrap();

18
src/types/payload.rs
View File

@ -386,7 +386,7 @@ mod tests {
"payload is probably json string" "payload is probably json string"
} }
let mut srv = init_service( let srv = init_service(
App::new() App::new()
.service( .service(
web::resource("/bytes-app-data") web::resource("/bytes-app-data")
@ -416,43 +416,43 @@ mod tests {
.await; .await;
let req = TestRequest::with_uri("/bytes-app-data").to_request(); let req = TestRequest::with_uri("/bytes-app-data").to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::BAD_REQUEST); assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
let req = TestRequest::with_uri("/bytes-data").to_request(); let req = TestRequest::with_uri("/bytes-data").to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::BAD_REQUEST); assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
let req = TestRequest::with_uri("/string-app-data").to_request(); let req = TestRequest::with_uri("/string-app-data").to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::BAD_REQUEST); assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
let req = TestRequest::with_uri("/string-data").to_request(); let req = TestRequest::with_uri("/string-data").to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::BAD_REQUEST); assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
let req = TestRequest::with_uri("/bytes-app-data") let req = TestRequest::with_uri("/bytes-app-data")
.header(header::CONTENT_TYPE, mime::APPLICATION_JSON) .header(header::CONTENT_TYPE, mime::APPLICATION_JSON)
.to_request(); .to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
let req = TestRequest::with_uri("/bytes-data") let req = TestRequest::with_uri("/bytes-data")
.header(header::CONTENT_TYPE, mime::APPLICATION_JSON) .header(header::CONTENT_TYPE, mime::APPLICATION_JSON)
.to_request(); .to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
let req = TestRequest::with_uri("/string-app-data") let req = TestRequest::with_uri("/string-app-data")
.header(header::CONTENT_TYPE, mime::APPLICATION_JSON) .header(header::CONTENT_TYPE, mime::APPLICATION_JSON)
.to_request(); .to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
let req = TestRequest::with_uri("/string-data") let req = TestRequest::with_uri("/string-data")
.header(header::CONTENT_TYPE, mime::APPLICATION_JSON) .header(header::CONTENT_TYPE, mime::APPLICATION_JSON)
.to_request(); .to_request();
let resp = call_service(&mut srv, req).await; let resp = call_service(&srv, req).await;
assert_eq!(resp.status(), StatusCode::OK); assert_eq!(resp.status(), StatusCode::OK);
} }