mirror of
https://github.com/actix/actix-web.git
synced 2024-11-20 08:31:09 +00:00
111 lines
3.3 KiB
Rust
111 lines
3.3 KiB
Rust
extern crate actix;
|
|
extern crate actix_web;
|
|
extern crate tokio_core;
|
|
extern crate reqwest;
|
|
|
|
use std::{net, thread};
|
|
use std::sync::Arc;
|
|
use std::sync::atomic::{AtomicUsize, Ordering};
|
|
use tokio_core::net::TcpListener;
|
|
|
|
use actix::*;
|
|
use actix_web::*;
|
|
|
|
fn create_server<T, A>() -> HttpServer<T, A, Application<()>> {
|
|
HttpServer::new(
|
|
vec![Application::default("/")
|
|
.resource("/", |r|
|
|
r.handler(Method::GET, |_, _, _| {
|
|
httpcodes::HTTPOk
|
|
}))
|
|
.finish()])
|
|
}
|
|
|
|
#[test]
|
|
fn test_serve() {
|
|
thread::spawn(|| {
|
|
let sys = System::new("test");
|
|
let srv = create_server();
|
|
srv.serve::<_, ()>("127.0.0.1:58902").unwrap();
|
|
sys.run();
|
|
});
|
|
assert!(reqwest::get("http://localhost:58902/").unwrap().status().is_success());
|
|
}
|
|
|
|
#[test]
|
|
fn test_serve_incoming() {
|
|
let loopback = net::Ipv4Addr::new(127, 0, 0, 1);
|
|
let socket = net::SocketAddrV4::new(loopback, 0);
|
|
let tcp = net::TcpListener::bind(socket).unwrap();
|
|
let addr1 = tcp.local_addr().unwrap();
|
|
let addr2 = tcp.local_addr().unwrap();
|
|
|
|
thread::spawn(move || {
|
|
let sys = System::new("test");
|
|
|
|
let srv = create_server();
|
|
let tcp = TcpListener::from_listener(tcp, &addr2, Arbiter::handle()).unwrap();
|
|
srv.serve_incoming::<_, ()>(tcp.incoming()).unwrap();
|
|
sys.run();
|
|
|
|
});
|
|
|
|
assert!(reqwest::get(&format!("http://{}/", addr1))
|
|
.unwrap().status().is_success());
|
|
}
|
|
|
|
struct MiddlewareTest {
|
|
start: Arc<AtomicUsize>,
|
|
response: Arc<AtomicUsize>,
|
|
finish: Arc<AtomicUsize>,
|
|
}
|
|
|
|
impl Middleware for MiddlewareTest {
|
|
fn start(&self, _: &mut HttpRequest) -> Result<(), HttpResponse> {
|
|
self.start.store(self.start.load(Ordering::Relaxed) + 1, Ordering::Relaxed);
|
|
Ok(())
|
|
}
|
|
|
|
fn response(&self, _: &mut HttpRequest, resp: HttpResponse) -> HttpResponse {
|
|
self.response.store(self.response.load(Ordering::Relaxed) + 1, Ordering::Relaxed);
|
|
resp
|
|
}
|
|
|
|
fn finish(&self, _: &mut HttpRequest, _: &HttpResponse) {
|
|
self.finish.store(self.finish.load(Ordering::Relaxed) + 1, Ordering::Relaxed);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_middlewares() {
|
|
let num1 = Arc::new(AtomicUsize::new(0));
|
|
let num2 = Arc::new(AtomicUsize::new(0));
|
|
let num3 = Arc::new(AtomicUsize::new(0));
|
|
|
|
let act_num1 = Arc::clone(&num1);
|
|
let act_num2 = Arc::clone(&num2);
|
|
let act_num3 = Arc::clone(&num3);
|
|
|
|
thread::spawn(move || {
|
|
let sys = System::new("test");
|
|
|
|
HttpServer::new(
|
|
vec![Application::default("/")
|
|
.middleware(MiddlewareTest{start: act_num1,
|
|
response: act_num2,
|
|
finish: act_num3})
|
|
.resource("/", |r|
|
|
r.handler(Method::GET, |_, _, _| {
|
|
httpcodes::HTTPOk
|
|
}))
|
|
.finish()])
|
|
.serve::<_, ()>("127.0.0.1:58904").unwrap();
|
|
sys.run();
|
|
});
|
|
|
|
assert!(reqwest::get("http://localhost:58904/").unwrap().status().is_success());
|
|
|
|
assert_eq!(num1.load(Ordering::Relaxed), 1);
|
|
assert_eq!(num2.load(Ordering::Relaxed), 1);
|
|
assert_eq!(num3.load(Ordering::Relaxed), 1);
|
|
}
|